Spring详解+代码

野性酷女 2023-01-04 13:11 120阅读 0赞

## ** Spring5框架概述** ##

**本文主要内容**

IOC容器

AOP编程

JDBCTemplate

事务

1、Spring是轻量级的开源的JavaEE框架

2、Spring可以解决企业应用开发的复杂性

3、Spring有两个核心部分：IOC和AOP  
    (1)IOC：控制反转，把创建对象过程交给Spring进行管理  
    (2)AOP：面向切面，不修改源代码进行功能增强

4、Spring特点  
    \*方便解耦  
    \*Aop编程支持  
    \*方便程序测试  
    \*方便和其他框架进行整合  
    \*方便进行事务操作  
    \*降低API开发难度

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70][]

## IOC容器 ##

1、什么是IOC容器

（1）控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理

（2）使用 IOC 目的：为了耦合度降低

2、IOC底层原理

xml 解析、工厂模式、反射

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 1][]

IOC（BeanFactory接口）

1、IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂

2、Spring 提供 IOC 容器实现两种方式：（两个接口）

（1）BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用

\* **加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象**

（2）ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用

\* **加载配置文件时候就会把在配置文件对象进行创建**

3、ApplicationContext 接口有实现类

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 2][]

IOC操作Bean管理

1、什么是 Bean 管理

（0）Bean 管理指的是两个操作

（1）Spring 创建对象

（2）Spirng 注入属性

2、Bean 管理操作有两种方式

（1）基于 xml 配置文件方式实现

（2）基于注解方式实现

IOC操作bean管理(基于xml方式)

（1）在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建

（2）在 bean 标签有很多属性，介绍常用的属性

\* id 属性：唯一标识

\* class 属性：类全路径（包类路径）

（3）创建对象时候，默认也是执行无参数构造方法完成对象创建

2、基于 xml 方式注入属性

（1）DI：依赖注入，就是注入属性

### 基于xml方式创建对象 ###

**第一种注入方式：使用 set 方法进行注入**

（1）创建类，定义属性和对应的 set 方法

public class Book {
        private String bName;
        private String bAuthor;
        private String address;
    
        public void setbName(String bName) {
            this.bName = bName;
        }
    
        public void setbAuthor(String bAuthor) {
            this.bAuthor = bAuthor;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "Book{" +
                    "bName='" + bName + '\'' +
                    ", bAuthor='" + bAuthor + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }

（2）在 spring 配置文件配置对象创建，配置属性注入

**第二种注入方式：使用有参数构造进行注入**

（1）创建类，定义属性，创建属性对应有参数构造方法

public class Order {
        private String oName;
        private String address;
        public Order(String oName,String address){
            this.oName = oName;
            this.address = address;
        }
        @Override
        public String toString() {
            return "Order{" +
                    "oName='" + oName + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }

（2）在Spring文件中进行配置

**p 名称空间注入（了解）**

使用 p 名称空间注入，可以简化基于 xml 配置方式

（1）添加 p 名称空间在配置文件中

（2）进行属性注入，在 bean 标签里面进行操作

<bean id="book" class="school.xauat.spring5.Book" p:bName="九阳神功" p:bAuthor="无名氏">
    </bean>

### xml注入其他类型属性 ###

1、字面量

(1) null值

(2) 属性值包含特殊符号

<property name="address">
    <null/>
    </property>
    
    <property name="address">
        <value><![CDATA[<<南京>>]]></value>
    </property>

2、注入属性-外部bean

（1）创建两个类 service 类和 dao 类

public class UserService {
    
        private UserDao userDao;
    
        public void setUserDao(UserDao userDao){
            this.userDao = userDao;
        }
    
        public void add(){
            System.out.println("UserService add.....");
    
            userDao.update();
        }
    }

public class User {
        public void add(){
            System.out.println("add........");
        }
    }

（2）在 service 调用 dao 里面的方法

（3）在 spring 配置文件中进行配置

3、注入属性-内部 bean

（1）一对多关系：部门和员工一个部门有多个员工，一个员工属于一个部门部门是一，员工是多

（2）在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示

public class Emp {
        private String eName;
        private String gender;
        private Dept dept;
        public void seteName(String eName){
            this.eName = eName;
        }
        public Dept getDept(){
            return dept;
        }
        public void setGender(String gender){
            this.gender = gender;
        }
        public void setDept(Dept dept){
            this.dept = dept;
        }
        @Override
        public String toString() {
            return "Emp{" +
                    "eName='" + eName + '\'' +
                    ", gender='" + gender + '\'' +
                    ", dept=" + dept +
                    '}';
        }
    }

public class Dept {
        private String dName;
        public void setdName(String dName){
            this.dName = dName;
        }
        @Override
        public String toString() {
            return "Dept{" +
                    "dName='" + dName + '\'' +
                    '}';
        }
    }

在配置文件中配置

4、注入属性-级联赋值

两种写法如下

<bean id="emp" class="school.xauat.spring5.bean.Emp">
        <property name="eName" value="lucy"></property>
        <property name="gender" value="女"></property>
        <property name="dept" ref="dept"></property>
        <property name="dept.dName" value="技术部"></property>
    </bean>
    <bean id="dept" class="school.xauat.spring5.bean.Dept"></bean>

### xml注入集合类型属性 ###

这里就直接写配置文件了，类的创建就不做过多的赘述了

1、数组

2、List集合

3、Map集合

4、在集合中设置对象类型值

<bean id="stu" class="school.xauat.bean.Stu">
        <property name="courses">
            <array>
                <value>java课程</value>
                <value>数据库课程</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>张三</value>
                <value>小三</value>
            </list>
        </property>
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>
        <property name="sets">
            <set>
                <value>MYSQL</value>
                <value>Redis</value>
            </set>
        </property>
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>
    <bean id="course1" class="school.xauat.bean.Course">
        <property name="cName" value="Spring5框架"></property>
    </bean>
    <bean id="course2" class="school.xauat.bean.Course">
        <property name="cName" value="MyBatis框架"></property>
    </bean>

5、把集合注入部分提取出来

在spring配置文件中引入名称空间util

xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                         http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

使用util标签完成list集合注入提取

<util:list id="bookList">
        <value>九阳神功</value>
        <value>易筋经</value>
        <value>道德经</value>
    </util:list>
    <bean id="book" class="school.xauat.bean.Book">
        <property name="list" ref="bookList"></property>
    </bean>

### FactoryBean ###

1、Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean） 2、普通 bean：在配置文件中定义 bean 类型就是返回类型

3、工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样

第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean

public class MyBean implements FactoryBean<Course> {
        @Override
        public Course getObject() throws Exception {
            Course course = new Course();
            course.setcName("d13");
            return course;
        }
        @Override
        public Class<?> getObjectType() {
            return null;
        }
        @Override
        public boolean isSingleton() {
            return false;
        }
    }

第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型

public void TestMyBean(){
        //加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
        //获取配置文件创建对象
        Course course = context.getBean("myBean",Course.class);
        System.out.println(course);
    }

### bean的作用域 ###

spring中设置创建的对象是单例还是多例

如何设置单实例还是多实例

（1）在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例

（2）scope 属性值

第一个值 默认值，singleton，表示是单实例对象

第二个值 prototype，表示是多实例对象

<bean id="book" class="school.xauat.bean.Book" scope="prototype">
        </bean>

singleton 和 prototype 区别

第一 singleton 单实例，prototype 多实例

第二 设置 scope 值是 singleton 时候，加载 spring 配置文件时候就会创建单实例对象

设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建 对象，在调用getBean 方法时候创建多实例对象、

### bean生命周期 ###

1、生命周期

（1）从对象创建到对象销毁的过程

2、bean 生命周期

（1）通过构造器创建 bean 实例（无参数构造）

（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）

把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization

（3）调用 bean 的初始化的方法（需要进行配置初始化的方法）

把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization

（4）bean 可以使用了（对象获取到了）

（5）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

3、演示 bean 生命周期

创建对象

public class Order {
        private String oName;
        private String address;
        public Order(){
            System.out.println("第一步 通过构造器创建bean实例对象");
        }
        public void setoName(String oName) {
            this.oName = oName;
            System.out.println("第二步 调用set方法设置属性");
        }
        public void setAddress(String address) {
            this.address = address;
        }
        public void initMethod(){
            System.out.println("第四步 初始化对象");
        }
        public void destroyMethod(){
            System.out.println("第七步 销毁对象");
        }

创建后置处理器

public class MyBeanPost implements BeanPostProcessor {
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("第三步 在初始化之前执行的方法");
            return null;
        }
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("第五步 在初始化之后执行的方法");
            return null;
        }
    }

测试

public void TestOrders(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        Order order = context.getBean("order", Order.class);
        System.out.println("第六步 获取到对象");
        System.out.println(order);
        ((ClassPathXmlApplicationContext)context).close();
    }

### xml自动装配 ###

1、什么是自动装配

（1）根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入

2、演示自动装配过程

（1）根据属性名称自动注入

（2）根据属性类型自动注入

xml配置外部属性文件、

1、引入context名称空间

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/util http://www.springframework.org/schema/util/spring-util.xsd">

2、连接Druid连接池

这里jdbc.properties是配置文件

<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    
    
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        
        
        <property name="driverClassName" value="${jdbc.driverclass}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

### 基于注解方式创建对象 ###

1、什么是注解

（1）注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值..)

（2）使用注解，注解作用在类上面，方法上面，属性上面

（3）使用注解目的：简化 xml 配置

2、Spring 针对 Bean 管理中创建对象提供注解

（1）@Component

（2）@Service

（3）@Controller

（4）@Repository

\* 上面四个注解功能是一样的，都可以用来创建 bean 实例

3、基于注解方式实现对象创建

1、引入依赖

![20210109233547551.png][]

2、开启组件扫描

<context:component-scan base-package="school.xauat"></context:component-scan>

3、创建类，在类上面添加创建对象注解

@Service(value = "userService")
    public class UserService {
    }

4、开启注解扫描细节配置

<context:component-scan base-package="school.xauat" use-default-filters="false">
        <context:include-filter type="annotation"
                                expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
    
    <context:component-scan base-package="school.xauat">
        <context:exclude-filter type="annotation"
                                expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

### 基于注解方式实现属性注入 ###

（1）@Autowired：根据属性类型进行自动装配

第一步 把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解

第二步 在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

（2）@Qualifier：根据名称进行注入

这个@Qualifier 注解的使用，和上面@Autowired 一起使用

（3）@Resource：可以根据类型注入，可以根据名称注入

（4）@Value：注入普通类型属性

@Service(value = "userService")
    public class UserService {
        /*@Autowired
        @Qualifier(value = "userDaoImpl")
        private UserDao userDao;*/
        @Value("zhangsan")
        private String userName;
        @Resource
        private UserDao userDao;
        public void add(){
            System.out.println("service add.....");
            userDao.add();
            System.out.println(userName);
        }
    }

### 完全注解开发 ###

1、创建配置类，替代xml配置文件

@Configuration
    //数组形式
    @ComponentScan(basePackages = {"school.xauat"})
    public class SpringConfig {
    }

2、编写测试类

@org.junit.Test
    public void testUserService1(){
        //加载Spring配置文件
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        //获取配置文件创建对象
        UserService userService = context.getBean("userService",UserService.class);
        userService.add();
    }

## AOP概念 ##

1、什么是 AOP

（1）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得

业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

（2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能

（3）使用登录例子说明 AOP

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 3][]

### AOP底层原理 ###

1、AOP 底层使用动态代理

（1）有两种情况动态代理

第一种 有接口情况，使用 JDK 动态代理创建接口实现类代理对象，增强类的方法

第二种 没有接口情况，使用 CGLIB 动态代理

创建子类的代理对象，增强类的方法

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 4][]

### JDK动态代理演示 ###

1、创建接口以及接口实现类

public interface UserDao {
        int add(int a,int b);
        String update(String id);
    }
    public class UserDaoImpl implements UserDao{
        @Override
        public int add(int a, int b) {
            return a + b;
        }
        @Override
        public String update(String id) {
            return id;
        }
    }

2、创建InvocationHandler接口实现类

public class UserDaoProxy implements InvocationHandler {
        private Object target;
        public UserDaoProxy(Object target){
            this.target = target;
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("法法执行之前" + method.getName() + "传递参数" + Arrays.toString(args));
            //被增强的方法执行
            Object obj = method.invoke(target,args);
            System.out.println("方法执行后" + target);
            return obj;
        }
    }

3、测试JDK动态代理

public class JDKProxy {
        public static void main(String[] args) {
            Class[] interfaces = {UserDao.class};
            UserDao dao = new UserDaoImpl();
            UserDao userDao = (UserDao)
                    Proxy.newProxyInstance(UserDaoImpl.class.getClassLoader(),interfaces,new UserDaoProxy(dao));
            int res = userDao.add(1,1);
            System.out.println(res);
            System.out.println(userDao.update("abc"));
        }
    }

执行结果

![20210110123649544.png][]

### AOP术语 ###

1、连接点

类里面那些方法可以被增强，这些方法称为连接点

2、切入点

实际被真正增强的方法称为切入点

3、通知(增强)

实际增强的逻辑部分称为通知

通知有多中类型：前置通知、后置通知、环绕通知、异常通知、最终通知

4、切面(是一个过程)

把通知应用到切入点的过程

### AOP操作 ###

1、Spring 框架一般都是基于 AspectJ 实现 AOP 操作

（1）AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用，进行 AOP 操作

2、基于 AspectJ 实现 AOP 操作

（1）基于 xml 配置文件实现

（2）基于注解方式实现（使用）

3、在工程里面引入AOP的相关依赖

4、切入点表达式

（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强

（2）语法结构： execution(\[权限修饰符\] \[返回类型\] \[类全路径\] \[方法名称\](\[参数列表\]) )

下面代码中有具体的举例

### 基于注解的方式实现AOP操作 ###

1、创建被增强类和增强类，并且加入@Component注解和@Aspect注解

在这里演示一下五种通知的使用

//被增强的类
    @Component(value = "user")
    public class User {
        public void add(){
            //int res = 10 / 0;
            System.out.println("User add...");
            //throw new RuntimeException("Exception...");
        }
    }

//增强的代理类
    @Component
    @Aspect
    public class UserProxy {
        
        //前置通知
        @Before(value = "execution(* school.xauat.aopanno.User.add(..))")
        public void before(){
            System.out.println("before...");
        }
        //后置通知
        @AfterReturning(value = "execution(* school.xauat.aopanno.User.add(..))")
        public void afterReturn(){
            System.out.println("afterReturn...");
        }
        //最终通知
        @After(value = "execution(* school.xauat.aopanno.User.add(..))")
        public void after(){
            System.out.println("after...");
        }
        //异常通知
        @AfterThrowing(value = "execution(* school.xauat.aopanno.User.add(..))")
        public void afterThrowing(){
            System.out.println("afterThrowing...");
        }
        //环绕通知
        @Around(value = "execution(* school.xauat.aopanno.User.add(..))")
        public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
            System.out.println("before around...");
            proceedingJoinPoint.proceed();
            System.out.println("after around...");
        }
    }

2、在xml配置文件中配置

开启注解扫描

开启Aspect生成代理对象

运行结果展示

![20210110130430550.png][]

### 相同切入点的提取 ###

@Pointcut(value = "execution(* school.xauat.aopanno.User.add(..))")
    public void pointDemo(){
    }
    //前置通知
    @Before(value = "pointDemo()")
    public void before(){
        System.out.println("before...");
    }

有多个类对同一个方法进行增强的时候，可以设置增强类的优先级别

使用@Order注解

### 基于xml配置文件实现AOP操作 ###

1、创建增强类和被增强类，并创建方法

public class Book {
        public void buy(){
            System.out.println("buy.......");
        }
    }

public class BookProxy {
        public void before(){
            System.out.println("before.......");
        }
    }

2、在Spring配置文件中创建两个类的对象

<bean id="book" class="school.xauat.aopxml.Book"></bean>
    <bean id="bookProxy" class="school.xauat.aopxml.BookProxy"></bean>
    
    <aop:config>
        
        <aop:pointcut id="point" expression="execution(* school.xauat.aopxml.Book.buy(..))"/>
        
        <aop:aspect ref="bookProxy">
            <aop:before method="before" pointcut-ref="point"></aop:before>
        </aop:aspect>
    </aop:config>

### 完全基于注解开发 ###

创建注解类

@Configuration
    @ComponentScan(basePackages = {"school.xauat"})
    @EnableAspectJAutoProxy(proxyTargetClass = true)
    public class ConfigAop {
    }

## JDBCTemplate ##

1、什么是 JdbcTemplate

（1）Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作

2、准备工作

引入相关jar包 druid连接池、数据库连接jar包、三个Spring包下的jar包

![20210110132043131.png][]

3、在Spring文件中配置数据库连接池

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverclass}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

4、配置JdbcTemplate对象，注入DataSource属性

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

5、创建service类，创建dao类，注入jdbcTemplate对象

查询返回对象

查询返回集合

实现批量添加操作

实现批量修改操作

public interface UserDao {
        int add(User user);
        int update(User user);
        int delete(String user_id);
        int searchCount();
        User searchById(String user_id);
        List<User> searchAll();
        //批量添加
        int[] addBatch(List<Object[]> batchArgs);
    }

@Service(value = "userService")
    public class UserService {
        @Autowired
        private UserDao userDao;
        public int addUser(User user){
            return userDao.add(user);
        }
        public int updateUser(User user){
            return userDao.update(user);
        }
        public void deleteUser(String user_id){
            userDao.delete(user_id);
        }
        public int searchCount(){
            return userDao.searchCount();
        }
        public User searchById(String user_id){
            return userDao.searchById(user_id);
        }
        public List<User> searchAll(){
            return userDao.searchAll();
        }
        public int[] addBatch(List<Object[]> batchArgs){
            return userDao.addBatch(batchArgs);
        }
    }

@Repository(value = "userDaoImpl")
    public class UserDaoImpl implements UserDao{
        @Autowired
        private JdbcTemplate jdbcTemplate;
        @Override
        public int add(User user) {
            String sql = "insert into t_user values(?,?,?)";
            Object[] args = {user.getUser_id(),user.getUsername(),user.getUstatus()};
            return jdbcTemplate.update(sql,args);
        }
        @Override
        public int update(User user) {
            String sql = "update t_user set username = ?,ustatus = ? where user_id = ?";
            Object[] args = {user.getUsername(),user.getUstatus(),user.getUser_id()};
            return jdbcTemplate.update(sql,args);
        }
        @Override
        public int delete(String user_id) {
            String sql = "delete from t_user where user_id = ?";
            return jdbcTemplate.update(sql,user_id);
        }
        @Override
        public int searchCount() {
            String sql = "select count(*) from t_user";
            return jdbcTemplate.queryForObject(sql,Integer.class);
        }
        @Override
        public User searchById(String user_id) {
            String sql = "select * from t_user where user_id = ?";
            return jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<User>(User.class),user_id);
        }
        @Override
        public List<User> searchAll() {
            String sql = "select * from t_user";
            return jdbcTemplate.query(sql,new BeanPropertyRowMapper<User>(User.class));
        }
        @Override
        public int[] addBatch(List<Object[]> batchArgs) {
            String sql = "insert into t_user values(?,?,?)";
            return jdbcTemplate.batchUpdate(sql,batchArgs);
        }
    }

## 事务操作 ##

1、什么事务

（1）事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败

（2）典型场景：银行转账

\* lucy 转账 100 元 给 mary

\* lucy 少 100，mary 多 100

2、事务四个特性（ACID）

（1）原子性

（2）一致性

（3）隔离性

（4）持久性

### 基于注解的方式实现 ###

模拟转账代码实现

1、数据库添加数据

![20210110135130555.png][]

2、创建用户类

public class Account {
        private String id;
        private String username;
        private Integer money;
        public String getId() {
            return id;
        }
        public void setId(String id) {
            this.id = id;
        }
        public String getUsername() {
            return username;
        }
        public void setUsername(String username) {
            this.username = username;
        }
        public Integer getMoney() {
            return money;
        }
        public void setMoney(Integer money) {
            this.money = money;
        }
        @Override
        public String toString() {
            return "Account{" +
                    "id='" + id + '\'' +
                    ", username='" + username + '\'' +
                    ", money=" + money +
                    '}';
        }
    }

3、创建AccountDao接口类和实现类

public interface AccountDao {
        int update(Account account);
        Account searchById(String id);
    }

@Repository(value = "accountDaoImpl")
    public class AccountDaoImpl implements AccountDao{
        @Autowired
        private JdbcTemplate jdbcTemplate;
        @Override
        public int update(Account account) {
            String sql = "update t_account set username = ?,money = ? where id = ?";
            Object[] args = {account.getUsername(),account.getMoney(),account.getId()};
            return jdbcTemplate.update(sql,args);
        }
        @Override
        public Account searchById(String id) {
            String sql = "select * from t_account where id = ?";
            return jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<Account>(Account.class),id);
        }
    }

4、创建Service类完成业务逻辑并且在Service层开启事务

@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
    @Service(value = "accountService")
    public class AccountService {
        @Autowired
        private AccountDao accountDao;
        public void setAccountDao(AccountDao accountDao) {
            this.accountDao = accountDao;
        }
        public boolean transfer(String id1, String id2){
            Account account1 = accountDao.searchById(id1);
            Account account2 = accountDao.searchById(id2);
            if (account1.getMoney() >= 100){
                int money = account1.getMoney() - 100;
                account1.setMoney(money);
                accountDao.update(account1);
                //int res = 10/0;
                account2.setMoney(account2.getMoney() + 100);
                accountDao.update(account2);
                return true;
            }
            return false;
        }
        public Account searchById(String id){
            return accountDao.searchById(id);
        }
    }

5、xml文件中配置

<context:component-scan base-package="school.xauat"></context:component-scan>
    
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>
    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
    
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverclass}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

### 事务中参数配置 ###

propagation：事务传播行为

多事务方法直接进行调用，这个过程中事务 是如何进行管理的

-REQUIRED       本身方法中有事务，调用方法后，方法使用该事务，本身没有事务，该方法创建新的事务

-REQUIRED\_NEW   无论本身方法是否有方法，调用方法都会产生新的事务

ioslation：事务隔离级别

（1）事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题

（2）有三个读问题：脏读、不可重复读、虚（幻）读

（3）脏读：一个未提交事务读取到另一个未提交事务的数据

（4）不可重复读：一个未提交事务读取到另一提交事务修改数据

（5）虚读：一个未提交事务读取到另一提交事务添加数据

（6）解决：通过设置事务隔离级别，解决读问题

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 5][]

timeout:超过时间自动回滚

readOnly:是否只读true表示只能查询，false表示可以进行CRUD操作

rollbackFor:设置出现哪些异常进行回滚

noRollbackFor:设置出现哪些异常不进行回滚

### 基于xml文件的实现 ###

配置文件，相比于基于注解的方式添加了配置通知和配置切入点和切面

<bean id="accountService" class="school.xauat.service.AccountService">
        <property name="accountDao" ref="accountDaoImpl"></property>
    </bean>
    <bean id="accountDaoImpl" class="school.xauat.dao.AccountDaoImpl"></bean>
    
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>
    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
    
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverclass}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <tx:advice id="txadvice">
        
        <tx:attributes>
            
            <tx:method name="transfer" propagation="REQUIRED"/>
            
            <tx:method name="add*" propagation="REQUIRED"></tx:method>
            <tx:method name="*" propagation="REQUIRED"></tx:method>
        </tx:attributes>
    </tx:advice>
    
    <aop:config>
        
        <aop:pointcut id="pt" expression="execution(* school.xauat.service.AccountService.*(..))"/>
        
        
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"></aop:advisor>
    </aop:config>

### 完全基于注解声明事务 ###

创建配置类

@Configuration//配置类声明
    @ComponentScan(basePackages = "school.xauat")//开启直接扫描
    @EnableTransactionManagement//开启事务
    public class ConfigClass {
        //创建数据库连接池
        @Bean
        public DruidDataSource getDruidDataSource(){
            DruidDataSource druidDataSource = new DruidDataSource();
            druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
            druidDataSource.setUrl("jdbc:mysql://localhost:3306/spring5");
            druidDataSource.setUsername("root");
            druidDataSource.setPassword("333");
            return druidDataSource;
        }
        //创建JdbcTemplate对象
        @Bean
        public JdbcTemplate getJdbcTemplate(DataSource dataSource){
            JdbcTemplate jdbcTemplate = new JdbcTemplate();
            jdbcTemplate.setDataSource(dataSource);
            return jdbcTemplate;
        }
        //创建事务管理器
        @Bean
        public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
            DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
            dataSourceTransactionManager.setDataSource(dataSource);
            return dataSourceTransactionManager;
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70]: /images/20221119/191a707c271948bb97f3d51af4c085d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 1]: /images/20221119/feba91156985411ba85ff3af3583d521.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 2]: /images/20221119/366f0af562a54f64990bd3684849d32b.png
[20210109233547551.png]: /images/20221119/72279c13fc30440ba6c29dd23eb0296d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 3]: /images/20221119/94dbfcff30c045689d0179b7aca76378.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210110122925877.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4,size_16,color_FFFFFF,t_70
[20210110123649544.png]: https://img-blog.csdnimg.cn/20210110123649544.png
[20210110130430550.png]: https://img-blog.csdnimg.cn/20210110130430550.png
[20210110132043131.png]: https://img-blog.csdnimg.cn/20210110132043131.png
[20210110135130555.png]: https://img-blog.csdnimg.cn/20210110135130555.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210110135904496.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4,size_16,color_FFFFFF,t_70