Spring04

最新推荐文章于 2023-07-24 15:37:20 发布
最新推荐文章于 2023-07-24 15:37:20 发布
阅读量149 收藏
点赞数
分类专栏： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WYJ____/article/details/103756550
版权

1.为什么要使用Spring提供的jdbc封装

2.JdbcTemplate的增删改查

3.JdbcDaoSupport

4.转账案例

5.Spring对事物的支持

6.XML的事务配置

7.事务方法的属性

8.注解的事务配置

 

一、为什么要使用Spring提供的jdbc封装

小结:

      1.使用Spring为我们提供的模板类以及基类可以简化开发.

      2.不同的持久化技术,Spring提供了不同的模板类和基类.

二、JdbcTemplate的增删改查

1、数据库

2、添加依赖     新增 Spring-jdbc Spring-tx

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.xj</groupId>
    <artifactId>Spring04</artifactId>
    <version>1.0.0</version>

    <properties>
        <!--定义全局变量，变量名为：project.spring.version-->
        <project.spring.version>5.0.0.RELEASE</project.spring.version>
    </properties>


    <dependencies>
        <!--Spring-core-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${project.spring.version}</version>
        </dependency>
        <!--Spring-beans-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${project.spring.version}</version>
        </dependency>
        <!--Spring-test-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${project.spring.version}</version>
        </dependency>
        <!--Spring-expression-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${project.spring.version}</version>
        </dependency>
        <!--Spring-context-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${project.spring.version}</version>
        </dependency>
        <!--Spring-aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${project.spring.version}</version>
        </dependency>

        <!--新增   Spring-jdbc    Spring-tx  -->
        <!--Spring-jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${project.spring.version}</version>
        </dependency>
        <!--Spring-tx-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${project.spring.version}</version>
        </dependency>



        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>


        <!--德鲁伊连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--mysql连接驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.20</version>
        </dependency>

        <!-- aspectjweaverr -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.2</version>
        </dependency>

    </dependencies>

    <build>
        <!--从哪个地方加载配置文件-->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
    </build>

</project>

3、实体类

package com.xj.bean;

import lombok.*;

import java.math.BigDecimal;
import java.util.Date;

/**
 * Created by Administrator on 2019/12/29 0029.
 */
@Setter@Getter@ToString
@NoArgsConstructor
@AllArgsConstructor
public class Employee {

    private Integer id;
    private String name;
    private Integer age;
    private Date hiredate;
    private BigDecimal salary;
}

4、dao

package com.xj.dao;

import com.xj.bean.Employee;

import java.util.List;

/**
 * Created by Administrator on 2019/12/29 0029.
 */
public interface IEmployeeDao {

    void save(Employee employee);

    void update(Employee employee);

    void delete(Integer id);

    List<Employee> list();

    Employee get(Integer id);
}

package com.xj.dao.impl;

import com.xj.bean.Employee;
import com.xj.dao.IEmployeeDao;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import javax.sql.DataSource;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

/**
 * Created by Administrator on 2019/12/29 0029.
 */

public class EmployeeDaoImpl implements IEmployeeDao{

    private JdbcTemplate jdbcTemplate;

    public void setDataSource(DataSource dataSource){
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }

    public void save(Employee employee) {
        this.jdbcTemplate.update(
                "insert into employee (name,age,hiredate,salary) values(?,?,?,?)",
                employee.getName(),employee.getAge(), employee.getHiredate(), employee.getSalary()
        );
    }

    public void update(Employee employee) {
        this.jdbcTemplate.update(
                "update employee set name=?,age=?,hiredate=?,salary=? where id=?",
                employee.getName(),employee.getAge(), employee.getHiredate(), employee.getSalary(), employee.getId()
        );
    }

    public void delete(Integer id) {
        this.jdbcTemplate.update(
                "delete from employee where id=?",
                id
        );
    }

    public List<Employee> list() {
        List<Employee> list = this.jdbcTemplate.query(
                "select * from employee",
                new RowMapper<Employee>() {
                    /*
                    * 方法的返回值，就会直接封装到集合中
                    * 第一个参数：结果集对象
                    * */
                    public Employee mapRow(ResultSet rs, int romNum) throws SQLException {
                        Employee employee = new Employee();
                        employee.setId(rs.getInt("id"));
                        employee.setName(rs.getString("name"));
                        employee.setAge(rs.getInt("age"));
                        employee.setHiredate(rs.getDate("hiredate"));
                        employee.setSalary(rs.getBigDecimal("salary"));
                        return employee;
                    }
                }
        );
        return list;
    }

    public Employee get(Integer id) {
       /* List<Employee> list = this.jdbcTemplate.query(
                "select * from employee where id=?",
                new Object[]{id},//数组 给sql语句赋值
                new RowMapper<Employee>() {
                    public Employee mapRow(ResultSet rs, int romNum) throws SQLException {
                        Employee employee = new Employee();
                        employee.setId(rs.getInt("id"));
                        employee.setName(rs.getString("name"));
                        employee.setAge(rs.getInt("age"));
                        employee.setHiredate(rs.getDate("hiredate"));
                        employee.setSalary(rs.getBigDecimal("salary"));
                        return employee;
                    }
                }
        );
        return list.size() > 0 ? list.get(0) : null;//如果查询的数据不存在，返回空
    }*/

       //如果查询的数据不存在，会报错
        Employee employee = this.jdbcTemplate.queryForObject(
                "select * from employee where id=?",
                new Object[]{id},
                new RowMapper<Employee>() {
                    public Employee mapRow(ResultSet rs, int romNum) throws SQLException {
                        Employee employee = new Employee();
                        employee.setId(rs.getInt("id"));
                        employee.setName(rs.getString("name"));
                        employee.setAge(rs.getInt("age"));
                        employee.setHiredate(rs.getDate("hiredate"));
                        employee.setSalary(rs.getBigDecimal("salary"));
                        return employee;
                    }
                }
        );
        return employee;
    }
}

5、配置文件

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring
jdbc.username=root
jdbc.password=root
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <context:property-placeholder location="db.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <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>

    <bean id="dao" class="com.xj.dao.impl.EmployeeDaoImpl">
        <property name="dataSource" ref="dataSource"/>
    </bean>

</beans>

6、测试类

package com.xj;

import com.xj.bean.Employee;
import com.xj.dao.IEmployeeDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.math.BigDecimal;
import java.util.Date;
import java.util.List;

/**
 * Created by Administrator on 2019/12/29 0029.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class App {

    @Autowired
    private  IEmployeeDao dao;


    @Test
    public void testSave(){
        Employee employee = new Employee(null,"rose",16,new Date(),new BigDecimal(1000));
        dao.save(employee);
    }

    @Test
    public void testUpdate(){
        Employee employee = new Employee(1,"jack",16,new Date(),new BigDecimal(2000));
        dao.update(employee);
    }

    @Test
    public void testDelete(){
        dao.delete(1);
    }

    @Test
    public void testList(){
        List<Employee> list = dao.list();
        System.out.println(list);
    }

    @Test
    public void testGet(){
        Employee employee = dao.get(20);
        System.out.println(employee);
    }

}

三、JdbcDaoSupport

dao了只需继承JdbcDaoSupport，则继承了JdbcTemplate字段和DataSource属性

package com.xj.dao.impl;

import com.xj.bean.Employee;
import com.xj.dao.IEmployeeDao;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

/**
 * Created by Administrator on 2019/12/29 0029.
 */

public class EmployeeDaoImpl extends JdbcDaoSupport implements IEmployeeDao{

    /*private JdbcTemplate jdbcTemplate;

    public void setDataSource(DataSource dataSource){
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }*/

    public void save(Employee employee) {
        super.getJdbcTemplate().update(
                "insert into employee (name,age,hiredate,salary) values(?,?,?,?)",
                employee.getName(),employee.getAge(), employee.getHiredate(), employee.getSalary()
        );
    }

    public void update(Employee employee) {
        super.getJdbcTemplate().update(
                "update employee set name=?,age=?,hiredate=?,salary=? where id=?",
                employee.getName(),employee.getAge(), employee.getHiredate(), employee.getSalary(), employee.getId()
        );
    }

    public void delete(Integer id) {
        super.getJdbcTemplate().update(
                "delete from employee where id=?",
                id
        );
    }

    public List<Employee> list() {
        List<Employee> list = super.getJdbcTemplate().query(
                "select * from employee",
                new RowMapper<Employee>() {
                    /*
                    * 方法的返回值，就会直接封装到集合中
                    * 第一个参数：结果集对象
                    * */
                    public Employee mapRow(ResultSet rs, int romNum) throws SQLException {
                        Employee employee = new Employee();
                        employee.setId(rs.getInt("id"));
                        employee.setName(rs.getString("name"));
                        employee.setAge(rs.getInt("age"));
                        employee.setHiredate(rs.getDate("hiredate"));
                        employee.setSalary(rs.getBigDecimal("salary"));
                        return employee;
                    }
                }
        );
        return list;
    }

    public Employee get(Integer id) {
       /* List<Employee> list = super.getJdbcTemplate().query(
                "select * from employee where id=?",
                new Object[]{id},
                new RowMapper<Employee>() {
                    public Employee mapRow(ResultSet rs, int romNum) throws SQLException {
                        Employee employee = new Employee();
                        employee.setId(rs.getInt("id"));
                        employee.setName(rs.getString("name"));
                        employee.setAge(rs.getInt("age"));
                        employee.setHiredate(rs.getDate("hiredate"));
                        employee.setSalary(rs.getBigDecimal("salary"));
                        return employee;
                    }
                }
        );
        return list.size() > 0 ? list.get(0) : null;//如果查询的数据不存在，返回空
    }*/

       //如果查询的数据不存在，会报错
        Employee employee = super.getJdbcTemplate().queryForObject(
                "select * from employee where id=?",
                new Object[]{id},
                new RowMapper<Employee>() {
                    public Employee mapRow(ResultSet rs, int romNum) throws SQLException {
                        Employee employee = new Employee();
                        employee.setId(rs.getInt("id"));
                        employee.setName(rs.getString("name"));
                        employee.setAge(rs.getInt("age"));
                        employee.setHiredate(rs.getDate("hiredate"));
                        employee.setSalary(rs.getBigDecimal("salary"));
                        return employee;
                    }
                }
        );
        return employee;
    }
}

四、转账案例

1、添加依赖，参考上面

2、数据库

3、实体类

package com.xj.bean;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

/**
 * Created by Administrator on 2019/12/30 0030.
 */
@Setter@Getter@ToString
public class Account {
    private Integer id;
    private Integer balance;
}

4、dao

package com.xj.dao;

/**
 * Created by Administrator on 2019/12/30 0030.
 */
public interface IAccountDao {
    void transIn(Integer inId,Integer money);
    void transOut(Integer OutId,Integer money);
}

package com.xj.dao.impl;

import com.xj.dao.IAccountDao;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

/**
 * Created by Administrator on 2019/12/30 0030.
 */
public class AccountDaoImpl implements IAccountDao{

    private JdbcTemplate jdbcTemplate;

    public void setDataSource(DataSource dataSource){
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }

    public void transIn(Integer inId, Integer money) {
        this.jdbcTemplate.update(
                "update account set balance=balance+? where id=?",
                money,inId
        );
    }

    public void transOut(Integer OutId, Integer money) {
        this.jdbcTemplate.update(
                "update account set balance=balance-? where id=?",
                money,OutId
        );
    }
}

5、service

package com.xj.service;

/**
 * Created by Administrator on 2019/12/30 0030.
 */
public interface IAccountService {
    void treans(Integer inID,Integer outId,Integer money);
}

package com.xj.service.impl;

import com.xj.dao.IAccountDao;
import com.xj.service.IAccountService;
import lombok.Setter;

/**
 * Created by Administrator on 2019/12/30 0030.
 */
public class AccountServiceImpl implements IAccountService{

    @Setter
    private IAccountDao dao;

    public void treans(Integer inId, Integer outId, Integer money) {
        dao.transIn(inId,money);
        dao.transOut(outId,money);
    }
}

6、配制文件 db.properties参考上面

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <context:property-placeholder location="db.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <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>

    <bean id="dao" class="com.xj.dao.impl.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <bean id="service" class="com.xj.service.impl.AccountServiceImpl">
        <property name="dao" ref="dao"/>
    </bean>

</beans>

7、测试类

package com.xj;

import com.xj.service.IAccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * Created by Administrator on 2019/12/29 0029.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class App {

    @Autowired
    private IAccountService service;

    @Test
    public void testTrans(){
        service.treans(1,2,1000);
    }
}

五、Spring对事物的支持

       在上面转账的案例中，如果没有事物，转账过程中出现了异常，如下图，那么转入的钱会增加，转出的钱并没有减少。造成数据不一致。

       

       解决方法：使用Spring的事务管理

Spring的事务管理主要包括3个接口：

       TransactionDefinition：封装事务的隔离级别,超时时间，是否为只读事务和事务的传播规则等事务属性，可通过XML配置具体信息。

       PlatformTransactionManager：根据TransactionDefinition提供的事务属性配置信息，创建事务。

       TransactionStatus：封装了事务的具体运行状态。比如，是否是新开启事务，是否已经提交事务，设置当前事务为rollback-only等。

Spring支持编程式事务管理和声明式事务管理：

      编程式事务管理：事务和业务代码耦合度太高。

      声明式事务管理：侵入性小，把事务从业务代码中抽离出来，提高维护性。XML/Annocation

Spring的事务管理：

1，PlatformTransactionManager:接口统一,抽取处理事务操作相关的方法；   

       1):TransactionStatus getTransaction(TransactionDefinition definition)：     根据事务定义信息从事务环境中返回一个已存在的事务，或者创建一个新的事务，并用TransactionStatus描述该事务的状态。

       2):void commit(TransactionStatus status)：     根据事务的状态提交事务，如果事务状态已经标识为rollback-only，该方法执行回滚事务的操作。 

      3):void rollback(TransactionStatus status)：将事务回滚，当commit方法抛出异常时，rollback会被隐式调用

2，在使用spring管理事务的时候，首先得告诉spring使用哪一个事务管理器； 

      常用的事务管理器：    DataSourceTransactionManager：使用JDBC,MyBatis的事务管理器；    HibernateTransactionManager：使用Hibernate的事务管理器；

六、XML的事务配置

   在xml文件中添加事务配置

    <!--事务管理器-->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--配置事务-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="txPointcut"
                      expression="execution( * com.xj.service.IAccountService.*(..))"/>
        <!--配置切面-->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"></aop:advisor>
    </aop:config>

    <!--事务增强器-->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="trans"/>
        </tx:attributes>
    </tx:advice>

        注：记得添加aop命名空间

        如果转账过程中没有出现异常，则转账成功。如果发生失败，则数据库中的数据不会发生改变。

七、事务方法的属性

事务方法属性：

      1,name:匹配到的方法模式;

      2,read-only:如果为true，开启一个只读事务，只读事务的性能较高，但是不能在只读事务中，使用DML；

      3,isolation:代表数据库事务隔离级别(就使用默认)   DEFAULT:让spring使用数据库默认的事务隔离级别;  其他:spring模拟;

      4,no-rollback-for: 如果遇到的异常是匹配的异常类型,就不回滚事务;

      5,rollback-for:如果遇到的异常是指定匹配的异常类型,才回滚事务;

               spring默认情况下,spring只会去回滚RuntimeException及其子类,不会回滚Exception和Thowable.

      6,propagation:事务的传播方式(当一个方法已经在一个开启的事务当中了，应该怎么处理自身的事务)

             1,REQUIRED（默认的传播属性）:如果当前方法运行在一个没有事务环境的情况下，则开启一个新的事务，如果当前方法运行在一个已经开启了的事务里面，把自己加入到开启的那个事务中  

             2,REQUIRES_NEW:不管当前方法是否运行在一个事务空间之内，都要开启自己的事务

           

通用的事务配置

    <!--事务增强器-->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <!--查询方法时只读事务，非查询的方法时只读事务-->
            <tx:method name="select*" read-only="true"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="query*" read-only="true"/>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="list*" read-only="true"/>
            <tx:method name="*" />
        </tx:attributes>
    </tx:advice>

八、注解的事务配置

1、配置注解方式

    <!--事务管理器-->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--事务的注解驱动-->
    <tx:annotation-driven transaction-manager="txManager"></tx:annotation-driven>

</beans>

2、实现类上添加注解

   注：如果想设置read-only，单独在方法上设置

通天云计算
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring框架从入门到精通
cgblpx的博客
06-08 3万+
初识Spring框架 时代变迁 原始时代我们用一个jsp搞定一切，但如此开发大型项目时我们遇到了问题，前端美化的代码和后端的代码交织，代码中又有html、js、css样式，又有业务逻辑和数据库访问代码，杂乱不清晰，美工和开发打架。 于是mvc分层架构封建时代出现，把我们写代码的地方硬性分成3个地方，Model层封装数据，View视图层页面展现，Controller控制层访问转发。代码之间的耦合度降低。概念有了，需要实际干活的。于是随着mvc分层概念的深入人心，业界涌现出很多实现框架，最著名的莫过于strut
数组
WYJ____的博客
11-02 1749
一、概述 数组：就是用于存储【相同数据类型】的数据的【容器】。 为什么要使用数组：没有数组，存在多个变量，需要声明多个变量的名称，这些名称之间没有什么关联，想访问所有的变量，比较困难。有了数组，只需要有一个数组容器的名称，容器里面有通过数字表示位置。同时这些数字位置有规律，结合数组名称非常容易的去访问所有的变量。数字位置可以称为索引，数组在内存中开辟了一块连续的内存...
springboot util 测试类怎么写_（很全面）SpringBoot 使用 Caffeine 本地缓存
weixin_39929595的博客
11-26 358
作者：超级小豆丁http://www.mydlq.club/article/56/目录一、本地缓存介绍二、缓存组件 Caffeine 介绍Caffeine 性能Caffeine 配置说明软引用与弱引用三、SpringBoot 集成 Caffeine 两种方式四、SpringBoot 集成 Caffeine 方式一Maven 引入相关依赖配置缓存配置类定义测试的实体对象定义服务接口类和实现类测试的 ...
狂神说Spring04：自动装配
热门推荐
狂神说
04-19 1万+
狂神说Spring系列连载课程，通俗易懂，基于Spring最新版本，欢迎各位狂粉转发关注学习。禁止随意转载，转载记住贴出B站视频链接及公众号链接！Bean的自动装配自动装配说明自动装配是...
Spring系列一：spring的安装与使用
最新发布
你好, 我在学java的博客
07-24 4566
Spring框架学习[上 50%]
Spring集成MyBatis
caijigskg的博客
04-08 5807
将mybatis与spring进行整合，主要解决的问题就是讲SqlSessionFactory对象交由spring来管理，所以，该整合，只需要将SqlSessionFactory的对象生成器SqlSessionFactoryBean注册在spring容器中，再将其注入给Dao的实现类即可完成整合。 实现spring与mybatis的整合常用的方式：扫描的Mapper动态代理 spring就像插线板一样，mybatis框架是插头，可以很容易的组合到一起。mybatis插头插入spring插线板就是一个整体
spring04-5
07-12
spring的aop的练习，代码可供参考，仅是aop功能实现，没有优化
spring04-4
07-12
spring的aop的练习，代码可供参考，仅是aop功能实现，没有优化
spring04-3
07-12
spring的aop的练习，代码可供参考，仅是aop功能实现，没有优化
spring04-2
07-12
spring的aop的练习，代码可供参考，仅是aop功能实现，没有优化
spring_day04
01-10
PlatformTransactionManager接口（平台事务管理器接口），不管使用哪种方式管理事务，这个类必须配置的！！
娱乐头条-03spider
WYJ____的博客
01-06 1734
1.确定首页的URL 访问这个URL https://pacaio.match.qq.com/irs/rcd?cid=146&token=49cbb2154853ef1a74ff4e53723372ce&ext=ent&page=1&expIds=20200106A0JR02|20200106A0JQFA|20200106A0JFB9|20200106...
IDEA
WYJ____的博客
12-18 996
1.IDEA简介 2.IDEA的安装 3.IDEA的使用 4.Maven关联IDEA 5.lombok插件 一、IDEA简介 IDEA 全称 IntelliJ IDEA，是java编程语言开发的集成环境。IntelliJ在业界被公认为最好的java开发工具之一，尤其在智能代码助手、代码自动提示、重构、J2EE支持、各类版本工具(git、svn等)、JUnit、CVS整...
集合泛型
WYJ____的博客
11-12 850
1.集合的概述 2.Collection 3.List 4.Vertor 5.Stack 6.ArrayList 7.LinkedList 8.Set 9.HashSet 10.TreeSet 11.泛型 12.Map 13.HashMap 14.Hashtable 15.TreeMap 16.LinkedHashMap 一、集合的概述 1.集合的概念 ...
Spring01
WYJ____的博客
12-26 758
1.解决什么问题 2.Spring简介 3.IoC和DI思想 4.HelloWorld 5.getBean的三种签名 6.Spring的基本配置 7.Spring的测试框架 8.Spring的IoC容器 9.Spring实例化对象 10.对象的作用域 11.对象的生命周期 一、解决什么问题 Spring出现之前,存在的问题: 1.代码耦合度比较高 ...
数据库—MySQL02
WYJ____的博客
11-26 756
1.事务 2.数据库约束 3.表关系 4.三范式 5.多表查询 6.数据库备份 一、事务 1.事务的应用场景说明 在实际的业务开发中，有些业务操作要多次访问数据库。一个业务要发送多条SQL语句给数据库执行。需要将多次访问数据库的操作视为一个整体来执行，要么所有的SQL语句全部执行成功。如果其中有一条SQL语句失败，就进行事务的回滚，所有的SQL语句全部执行失败。 ...
JSP
WYJ____的博客
12-10 690
1.JSP基础 2.EL表达式 一、JSP基础 1.简介 JSP（java server pages） Java服务器页面 静态网页：可以直接被浏览器渲染。但是不能做数据交互。 动态网页：不可以被浏览器直接渲染，需要第三方辅助，可以与Java进行数据交互操作。 JSP = html+java+jsp本身的标签 ...
异常
WYJ____的博客
11-12 620
一、异常的概念 异常的概念：在java程序运行过程中，出现的不正常的情况，出现的错误，称为异常。 异常就是一个对象，描述了那些不符合正常运行的情况，包含了这些情况的原因、类型、描述以及位置，这些内容都封装到异常对象中。 Java程序运行过程中所发生的异常事件可分为两类： Error：JAM系统内部错误、资源耗尽等严重情况 ...
常用类库
WYJ____的博客
11-07 608
1.API 2.Object类 3.String类 4.StringBuilder类 5.Arrays类 6.包装类 7.Math类 8.Random类 9.Date类 10.SimpleDateFormat 11.Calendar类 12.BigDecimal类 13.正则表达式 一、API 1.概念 API(Application Prog...
自动注入的closeablehttpclient对象总是空指针_狂神说Spring04：自动装配
06-13
这可能是因为您没有在Spring的配置文件中正确地配置CloseableHttpClient Bean，或者您的自动注入方式不正确。请确保您已经在配置文件中正确地声明了CloseableHttpClient Bean，并且使用了正确的注解（如@Autowired或@Resource）将其注入到需要使用它的类中。您还可以检查一下CloseableHttpClient Bean的作用域，确保它与您需要使用它的类的作用域相匹配。如果以上方法都无法解决问题，您可以尝试在代码中手动创建CloseableHttpClient对象并使用它。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值