Spring Boot 使用Druid出现Property: spring.datasource.filters 的错误

这个错误是因为在Spring Boot中使用Druid作为数据源时，没有设置正确的过滤器。可以尝试以下步骤来解决这个问题：

1. 确认在pom.xml文件中已经添加了Druid的依赖。

2. 在application.properties或application.yml文件中添加以下配置：

spring.datasource.filters=stat,wall,log4j

这个配置中的三个过滤器分别是：stat、wall和log4j，可以根据需要进行调整。

3. 如果以上配置仍然无法解决问题，可以尝试将Druid的配置放在一个单独的配置文件中，例如druid.properties。在application.properties或application.yml文件中添加以下配置：

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.druid.config-file=classpath:druid.properties

在druid.properties文件中添加以下配置：

druid.filters=stat,wall,log4j

这样就可以解决这个错误了。

相关问题

springboot mysql多数据源 druid加解密连接数据库代码

好的，下面是一个示例代码，使用Spring Boot和Druid连接MySQL多数据源，并且对数据库密码进行了加解密：

1. 添加依赖

在 pom.xml 文件中添加以下依赖：

<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>

    <!-- Spring Boot Starter JDBC -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>

    <!-- Druid -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.23</version>
    </dependency>

    <!-- Jasypt -->
    <dependency>
        <groupId>com.github.ulisesbocchio</groupId>
        <artifactId>jasypt-spring-boot-starter</artifactId>
        <version>3.0.3</version>
    </dependency>
</dependencies>

2. 配置数据源

在 application.yml 文件中添加以下配置：

# 默认数据源
spring.datasource.url=jdbc:mysql://localhost:3306/db1
spring.datasource.username=root
spring.datasource.password=ENC(加密后的密码)
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

# 第二个数据源
datasource2.url=jdbc:mysql://localhost:3306/db2
datasource2.username=root
datasource2.password=ENC(加密后的密码)
datasource2.driver-class-name=com.mysql.jdbc.Driver

其中，密码字段使用 Jasypt 进行加密，格式为 `ENC(加密后的密码)`。

3. 配置Druid数据源

在配置文件中添加以下配置：

# Druid数据源配置
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

# 配置第一个数据源
spring.datasource.druid.initial-size=5
spring.datasource.druid.min-idle=5
spring.datasource.druid.max-active=20
spring.datasource.druid.max-wait=60000
spring.datasource.druid.time-between-eviction-runs-millis=60000
spring.datasource.druid.min-evictable-idle-time-millis=300000
spring.datasource.druid.validation-query=SELECT 1 FROM DUAL
spring.datasource.druid.test-while-idle=true
spring.datasource.druid.test-on-borrow=false
spring.datasource.druid.test-on-return=false
spring.datasource.druid.pool-prepared-statements=true
spring.datasource.druid.max-pool-prepared-statement-per-connection-size=20
spring.datasource.druid.filters=stat,wall,log4j

# 配置第二个数据源
datasource2.druid.initial-size=5
datasource2.druid.min-idle=5
datasource2.druid.max-active=20
datasource2.druid.max-wait=60000
datasource2.druid.time-between-eviction-runs-millis=60000
datasource2.druid.min-evictable-idle-time-millis=300000
datasource2.druid.validation-query=SELECT 1 FROM DUAL
datasource2.druid.test-while-idle=true
datasource2.druid.test-on-borrow=false
datasource2.druid.test-on-return=false
datasource2.druid.pool-prepared-statements=true
datasource2.druid.max-pool-prepared-statement-per-connection-size=20
datasource2.druid.filters=stat,wall,log4j

4. 配置数据源连接池

在配置类中添加以下代码：

@Configuration
public class DataSourceConfig {

    @Bean(name = "dataSource")
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource")
    public DruidDataSource dataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = "dataSource2")
    @ConfigurationProperties(prefix = "datasource2")
    public DruidDataSource dataSource2() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = "dataSource1TransactionManager")
    @Primary
    public DataSourceTransactionManager dataSourceTransactionManager() {
        return new DataSourceTransactionManager(dataSource());
    }

    @Bean(name = "dataSource2TransactionManager")
    public DataSourceTransactionManager dataSource2TransactionManager() {
        return new DataSourceTransactionManager(dataSource2());
    }

    @Bean(name = "dataSource1SqlSessionFactory")
    @Primary
    public SqlSessionFactory dataSourceSqlSessionFactory(@Qualifier("dataSource") DruidDataSource dataSource) throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));
        return sessionFactory.getObject();
    }

    @Bean(name = "dataSource2SqlSessionFactory")
    public SqlSessionFactory dataSource2SqlSessionFactory(@Qualifier("dataSource2") DruidDataSource dataSource) throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper2/*.xml"));
        return sessionFactory.getObject();
    }
}

其中，`@Primary` 注解表示默认数据源，`@ConfigurationProperties` 注解表示从配置文件中读取配置。

5. 配置MyBatis

在 `application.yml` 文件中添加以下配置：

mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.example.entity

6. 编写DAO和Mapper

在 `com.example.dao` 包中编写DAO和Mapper，例如：

@Repository
public interface UserDAO {

    @Select("SELECT * FROM user")
    @Results(id = "userResultMap", value = {
            @Result(property = "id", column = "id", id = true),
            @Result(property = "name", column = "name"),
            @Result(property = "email", column = "email"),
            @Result(property = "phone", column = "phone"),
            @Result(property = "createTime", column = "create_time")
    })
    List<User> list();

}

@Mapper
public interface UserMapper {

    @Select("SELECT * FROM user")
    @ResultMap("userResultMap")
    List<User> list();

}

7. 使用数据源

在Service中使用数据源，例如：

@Service
public class UserService {

    @Autowired
    private UserDAO userDAO;

    @Autowired
    private UserMapper userMapper;

    @Transactional(transactionManager = "dataSource1TransactionManager")
    public List<User> list() {
        return userDAO.list();
    }

    @Transactional(transactionManager = "dataSource2TransactionManager")
    public List<User> list2() {
        return userMapper.list();
    }

}

其中，`@Transactional` 注解表示开启事务，`transactionManager` 参数指定使用的数据源。

自行设计一个数据库项目，分别采用Druid、Mybaties、JDBCTemplate的整合技术，通过定义xml依赖文件和properties属性配置文件，定义实体类，编写持久层、Service层、controller层，完成系统的CRUD功能。

好的，这个问题比较复杂，我会尽量详细地回答你。

首先，我们需要确定一个数据库项目的主题。为了方便，我们选择一个简单的学生信息管理系统。这个系统需要记录学生的基本信息，包括姓名、性别、年龄、班级、学号等，同时需要实现增删改查等基本功能。

接下来，我们分别使用Druid、Mybatis和JdbcTemplate来实现这个系统。

1. Druid整合

Druid是阿里巴巴开源的一个数据库连接池实现，具有监控、可扩展等优点，被广泛应用于企业级应用中。

首先，我们需要在项目中引入Druid的依赖，可以在pom.xml文件中添加以下代码：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>

接下来，我们需要在src/main/resources目录下创建一个druid.properties文件，并添加以下配置：

# 数据库连接信息
url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
driverClassName=com.mysql.jdbc.Driver
username=root
password=root

# Druid连接池信息
initialSize=5
minIdle=5
maxActive=20
maxWait=60000
timeBetweenEvictionRunsMillis=60000
minEvictableIdleTimeMillis=300000
validationQuery=SELECT 1 FROM DUAL
testWhileIdle=true
testOnBorrow=false
testOnReturn=false
poolPreparedStatements=true
maxPoolPreparedStatementPerConnectionSize=20
filters=stat,wall,log4j

其中，url是数据库连接地址，username和password是数据库登录的用户名和密码，其他配置是Druid连接池的一些参数。

接下来，我们需要定义实体类(Student)和Mapper接口(StudentMapper)，这个过程比较简单，这里就不再赘述。

最后，我们需要在Spring配置文件中添加以下配置：

<!-- 配置Druid连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
</bean>

<!-- 配置Mybatis -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="typeAliasesPackage" value="com.example.demo.entity" />
    <property name="mapperLocations" value="classpath*:com/example/demo/mapper/*.xml" />
</bean>

<!-- 配置Mapper扫描器 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.example.demo.mapper" />
</bean>

其中，dataSource是Druid连接池的配置，sqlSessionFactory是Mybatis的配置，mapperLocations是Mapper文件的路径，MapperScannerConfigurer是扫描Mapper接口的配置。

完成以上配置后，我们就可以在Controller层中调用Service层的方法来实现CRUD功能了。

2. Mybatis整合

Mybatis是一款优秀的持久层框架，可以与各种数据库连接池进行整合，应用广泛。

首先，我们需要在项目中引入Mybatis的依赖，可以在pom.xml文件中添加以下代码：

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.6</version>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.3</version>
</dependency>

接下来，我们需要在src/main/resources目录下创建一个mybatis-config.xml文件，并添加以下配置：

<configuration>
    <!-- 设置默认的执行器类型为REUSE -->
    <settings>
        <setting name="defaultExecutorType" value="REUSE" />
    </settings>
    <!-- 配置Mapper文件 -->
    <mappers>
        <mapper resource="mapper/StudentMapper.xml" />
    </mappers>
</configuration>

其中，defaultExecutorType是Mybatis的默认执行器类型，REUSE表示复用执行器，mapper是Mapper文件的路径。

接下来，我们需要定义实体类(Student)和Mapper接口(StudentMapper)，这个过程比较简单，这里就不再赘述。

最后，我们需要在Spring配置文件中添加以下配置：

<!-- 配置数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="${jdbc.driverClassName}" />
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
</bean>

<!-- 配置Mybatis -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="configLocation" value="classpath:mybatis-config.xml" />
</bean>

<!-- 配置Mapper扫描器 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.example.demo.mapper" />
</bean>

其中，dataSource是数据源的配置，sqlSessionFactory是Mybatis的配置，configLocation是Mybatis配置文件的路径，MapperScannerConfigurer是扫描Mapper接口的配置。

完成以上配置后，我们就可以在Controller层中调用Service层的方法来实现CRUD功能了。

3. JdbcTemplate整合

JdbcTemplate是Spring框架提供的一款轻量级的数据库访问工具，可以简化数据库操作。

首先，我们需要在项目中引入Spring JDBC的依赖，可以在pom.xml文件中添加以下代码：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>

接下来，我们需要在Spring配置文件中添加以下配置：

<!-- 配置数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="${jdbc.driverClassName}" />
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
</bean>

<!-- 配置JdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>

其中，dataSource是数据源的配置，jdbcTemplate是JdbcTemplate的配置。

接下来，我们需要定义实体类(Student)和RowMapper(StudentRowMapper)，这个过程比较简单，这里就不再赘述。

最后，我们需要在Service层中调用JdbcTemplate来实现CRUD功能，比如：

@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public List<Student> findAll() {
        String sql = "SELECT * FROM student";
        return jdbcTemplate.query(sql, new StudentRowMapper());
    }

    @Override
    public Student findById(Long id) {
        String sql = "SELECT * FROM student WHERE id=?";
        return jdbcTemplate.queryForObject(sql, new Object[]{id}, new StudentRowMapper());
    }

    @Override
    public void save(Student student) {
        String sql = "INSERT INTO student(name, gender, age, class, number) VALUES(?,?,?,?,?)";
        jdbcTemplate.update(sql, student.getName(), student.getGender(), student.getAge(), student.getClass(), student.getNumber());
    }

    @Override
    public void update(Student student) {
        String sql = "UPDATE student SET name=?, gender=?, age=?, class=?, number=? WHERE id=?";
        jdbcTemplate.update(sql, student.getName(), student.getGender(), student.getAge(), student.getClass(), student.getNumber(), student.getId());
    }

    @Override
    public void delete(Long id) {
        String sql = "DELETE FROM student WHERE id=?";
        jdbcTemplate.update(sql, id);
    }
}

其中，jdbcTemplate是JdbcTemplate的实例，query是查询方法，update是更新方法，queryForObject是查询单个对象方法。

完成以上配置后，我们就可以在Controller层中调用Service层的方法来实现CRUD功能了。

以上就是使用Druid、Mybatis和JdbcTemplate整合实现一个简单的学生信息管理系统的过程。希望能对你有所帮助。