Spring框架

视频来自：尚硅谷Spring框架

核心内容有：IOC、AOP、JdbcTemplate、事务管理

1. Spring

概述：

Spring是轻量级的开源的JavaEE框架Spring可以解决企业开发的复杂性拥有IOC和Aop两个核心部分

IOC：控制反转，把创建对象的过程交给Spring进行管理Aop：面向切面，不修改源代码进行功能增强

优点：

IOC方便解耦，简便开发AOP不改变源代码，增加其功能方便程序测试方便其他框架的整合降低API的开发难度

下载配置：

下载Spring5 下载GA版本（稳定版本）:https://repo.spring.io/release/org/springframework/spring/

下载之后压缩——>libs内是jar包——>导入spring包

2. IOC容器

​ **什么是IOC？**控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理；目的为了使耦合度降低。

demo:实现IOC创建对象
@Test
    public void UserTest() {
        //加载Spring配置文件
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("bean.xml");
        //获取配置创建对象
        User user = context.getBean("com.zju.User", User.class);
        user.add();
    }

2.1 IOC底层原理

xml解析、工厂模式、反射

​ 容器相对于对象工厂，通过读取配置文件，以反射(反射相当于从字节码文件中获取类的信息)创建对象。

第一步：xml配置文件，配置创建的对象

第二步：创建工厂类(解耦合，只需要改配置文件)

2.2 IOC操作接口

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

Spring提供IOC容器实现的两种方式(两个接口)：

BeanFactory：Spring 内部的使用接口，不提供开发人员进行使用。

*加载配置文件时不会创建对象，使用时才会

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

*加载配置文件时候就会创建对象（耗时操作在服务器启动时完成，慢启动快响应）

ClassPathXmlApplicationContext：实现类，写src下文件路径FileSystemXmlApplicationContext：实现类，写磁盘全路径

//加载Spring配置文件
ApplicationContext context = 
    new ClassPathXmlApplicationContext("bean.xml");
//获取配置创建对象
User user = context.getBean("com.zju.User", User.class);

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

Bean管理：Spring创建对象，Spring注入属性

2.3.1 基于xml方式创建对象

（1）使用bean标签添加对应属性即可实现对象创建

​ **id：**获取对象的唯一标识

​ **class:**类全路径

（2）默认执行无参构造方法完成对象创建

2.3.2 xml方式注入基本属性

DI：依赖注入，就是注入属性。是IOC的一种具体实现。

​ 1.第一种方式：使用set方法注入

创建类，定义属性和对应的set方法在spring配置文件进行对象创建和属性注入

​ 2.第二种方式：使用有参构造注入

创建类，定义属性，创建属性对应有参构造方法在Spring配置文件中进行配置

​ 3.p名称空间注入：（底层也是set方法注入）

2.3.3 xml注入其他类型属性

​ 1.字面量(属性初始值)

null值

包含特殊符号

    >]]>

​ 2.注入外部bean

建立两个类

public class UserService {//service类

    //创建UserDao类型属性，生成set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add() {
        System.out.println("service add...............");
        userDao.update();//调用dao方法
    }
}

public class UserDaoImpl implements UserDao {//dao类

    @Override
    public void update() {
        System.out.println("dao update...........");
    }
}

Spring注入，此时的属性是对象，要用ref

​ 3.注入内部bean

建立两个类，部门和员工，一对多

//部门类
public class Dept {
    private String dname;
    public void setDname(String dname) {
        this.dname = dname;
    }
}

//员工类
public class Emp {
    private String ename;
    private String gender;
    //员工属于某一个部门，使用对象形式表示
    private Dept dept;
    
    public void setDept(Dept dept) {
        this.dept = dept;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
}

通过spring配置

​ 通过外部bean注入方式也可达成相同效果，根据bean的相对位置区分内外部bean

​ 4.注入属性级联赋值

方法一：通过得外部对象bean创建赋值，再注入到内部

方法二：通过先注入外部对象，再在内部给该对象注入属性

​ 此时在emp类中要生成getDept()方法，因为dept.dname需要反射获取

​ 5. 注入数组/集合属性

​ Stu类中选了多门课String[] courses/List list/Set/Map map，生成set方法。

调用对象模板

//加载xml配置
ApplicationContext context =
	new ClassPathXmlApplicationContext("bean1.xml");
//获取对象
类名 对象名 = context.getBean("对象名", 类名.class);

（1）注入数组类型属性

    
        java课程
        数据库课程
    

（2）注入List集合类型属性

    
        张三
        小三
    

（3）注入Set集合属性

!--set类型属性注入-->

    
        MySQL
        Redis
    

（4）注入map集合属性

注意点：

1.在集合里面设置对象类型值 List courseList

2.把集合注入部分提取出来

使用util的名称空间注入

   //修改部分
    
    
        斗破苍穹
        斗罗大陆
        吞噬星空
    
    
    
    
        
    

2.4 工厂bean

spring有两种类型，一种是上面的普通bean，另一种是工厂bean

普通bean：在配置文件中，定义的bean类型就是返回类型工厂bean：在配置文件中定义bean类型可以和返回类型不一样

第一步：创建类，这个类作为工厂bean，实现接口FactoryBean第二步：实现接口方法，在getObject()方法中定义返回的bean类型

public class MyBean implements FactoryBean {

    //定义返回bean的类型
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }
    @Override
	public Class getObjectType() {
		return null;
	}
	@Override
	public boolean isSingleton() {
		return false;
	}
}

配置xml:

此时调用course类：

ApplicationContext context = 
    new ClassPathXmlApplicationContext("bean.xml");
Course course = context.getBean("myBean", Course.class);

2.5 bean作用域

在Spring里，设置创建bean实例是单实例（只有一个对象）还是多实例（每次都建一个新对象）

在Spring里，默认情况下，bean是单实例对象（加载配置文件时默认已经创建对象）

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

设置bean标签中的属性scope：singleton(单实例)、prototype(多实例)、request、session

区别：

设置singleton时，在spring加载配置文件时就会创建单实例对象设置prototype时，在调用getBean方法时才会创建多实例对象 2.6 bean生命周期

生命周期：从对象创建到销毁的过程

1.bean生命周期:

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

2.注入bean属性和其他bean引用（调用set方法）

(传递bean实例给bean后置处理器的方法)postProcessBeforeInitialization

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

(传递bean实例给bean后置处理器的方法)postProcessAfterInitialization

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

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

创建-DI(注入属性)-初始化-使用-销毁

演示过程：

配置xml，指定初始化方法和销毁方法

public class Orders {

    //无参数构造
    public Orders() {
        System.out.println("第一步 执行无参数构造创建bean实例");
    }

    private String oname;
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步 调用set方法设置属性值");
    }

    //创建执行的初始化的方法
    public void initMethod() {
        System.out.println("第三步 执行初始化的方法");
    }

    //创建执行的销毁的方法
    public void destroyMethod() {
        System.out.println("第五步 执行销毁的方法");
    }
}

 @Test
public void testBean3() {
    //        ApplicationContext context =
    //                new ClassPathXmlApplicationContext("bean4.xml");
    ClassPathXmlApplicationContext context =
        new ClassPathXmlApplicationContext("bean4.xml");
    Orders orders = context.getBean("orders", Orders.class);
    System.out.println("第四步 获取创建bean实例对象");
    System.out.println(orders);

    //手动让bean实例销毁
    context.close();
}

2.bean的后置处理器

位于bean生命周期初始化方法执行的前后

在xml配置后，会对当前xml中的所有bean都添加后置处理器

创建类，实现接口BeanPostProcessor

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

2.7 xml自动装配

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

根据属性名称：autowire=“byName”注入值的bean的id和属性名一致

根据属性类型：autowire=“byType” 注入bean的class与属性类型一致

此时，多个同源类型会报错

2.8 外部属性文件

配置德鲁伊连接池：

首先引入jar包

创建外部属性文件，properties格式文件，写数据库信息

//左边随便写
prop.driverClass=com.mysql.cj.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/fkddatabase
prop.userName=root
prop.password=123456

把外部properties属性文件引入到Spring配置文件中

引入context命名空间

在Spring配置文件使用标签引入外部属性文件

2.9 IOC操作Bean管理(基于注解)

注解是什么？

(1) 注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值）
(2) 可作用在类， 方法，属性上面
(3) 注解目的：简化xml配置

Spring针对Bean管理中创建对象提供的注解：

@Component： 普通的注解
@Service ：业务逻辑层以及Service层
@Controller： web层
@Repository ：dao层即持久层

功能是一样的，都可以用来创建对象，只不过把每个对象用在不同地方，以便查看

1. 基于注解方式实现对象创建：

第一步：引入额外的aop依赖jar包第二步：开启组件扫描(扫描包，寻找注解),使用context的名称空间(同上)

开启组件扫描详细配置：

以上扫描的是包中全注解，可以自定义扫描范围

use-default-filters=“false” 表示现在不使用默认 filter，自己配置 filter

context:include-filter ，设置扫描哪些内容

type只扫描这种注解类

expression表示扫描的为该注解类

context:exclude-filter： 设置哪些内容不进行扫描

实例一：只扫描包下Controller注解

第三步：创建类，在类上添加创建对象注解(四选一)

在注解里面value属性值可以省略不写,默认值是类名称，改首字母小写

//UserService -- userService
//@Component(value = "userService")  //
@Component
public class UserService {
	public void add() {
        System.out.println("service add......."+name);
        userDao.add();
    }
}

2. 基于注解方式实现属性注入：

@Autowired:根据属性类型进行自动装配

第一步：给service和dao类分别添加创建对象注解

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

@Service
public class UserService {
    //定义dao类型属性
    //不需要添加set方法,已经封装了
    //根据类型注入，会自动寻找实现类
    @Autowired
    private UserDao userDao;
    
    public void add(){
        userDao.add();
        System.out.println("service add...");
    }
}

@Qualifier:根据属性名称进行注入

@Qualifier注解和@Autowired配合一起使用，当有多个实现类时

@Autowired  //根据类型进行注入
@Qualifier(value = "userDaoImpl") //根据名称进行注入
private UserDao userDao;

@Resource:可以根据类型注入，也可以根据名称注入

​ 名称默认是类名称改首字母小写

//@Resource 根据类型注入
@Resource(name = "userDaoImpl1")  //根据名称进行注入
private UserDao userDao;

是javax包中的，不推荐使用

@value:注入普通类型

@Value(value = "abc")
private String name;

2.10 完全注解开发

1.创建配置类，替代xml配置文件进行组件扫描

@Configuration //作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.zju"})
public class SpringConfig {

}

2.加载配置类

//加载Spring配置类
ApplicationContext context =
    new AnnotationConfigApplicationContext(SpringConfig.class);
//创建对象
UserService userService = context.getBean("userService", UserService.class);
userService.add();

3.AOP

Aop为面向切面，不修改源代码进行功能增强可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高开发的效率

回顾下静态代理和动态代理：

静态代理模式：定义接口，核心类和代理类都实现该接口方法。代理类在构造方法中引入核心类对象，并在方法中调用。

弊端：一个代理类只为一个接口服务，耦合严重 动态代理模式：根据加载到内存之中的被代理类，在程序运行期间确定并动态创建代理类。能为所有功能一致的业务操作接口提供有统一的代理操作

举例实现：

package com.zju;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


interface Huaman{

    String getBelief();

    void eat(String food);
}
//被代理类
class SuperMan implements Huaman{

    @Override
    public String getBelief() {
        return "I believe I can fly";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃"+food);
    }
}


class ProxyFactory{
    
    public static Object getProxyInstance(Object obj){
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.bind(obj);
        //告诉代理类，被代理类是哪个类加载器加载，实现了哪些接口
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),handler);
    }
}

class MyInvocationHandler implements InvocationHandler{
    //需要使用被代理类的对象进行赋值
    private Object obj;

    public void bind(Object obj){
        this.obj = obj;
    }

    //当我们通过代理类对象，调用方法a时,就会自动调用如下的方法:invoke()
    //将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //method:此方法为被代理类的方法，也就是代理类要调用的方法
        Object returnValue = method.invoke(obj, args);
        //方法返回值
        return returnValue;
    }
}

public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //生成代理类
        Huaman proxyInstance = (Huaman) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动调用被代理类中同名的方法
        proxyInstance.eat("hamburger");
    }
}

运行结果：

=====通用方法一=====
我喜欢吃hamburger这是新功能哦(可以更换)
=====通用方法二=====

---

3.1 底层原理

底层使用的是动态代理，Spring5已经进行了封装

有接口的情况，使用JDK动态代理

创建接口实现类的代理对象，增强类的方法

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

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

3.2 JDK动态代理

动态代理主要涉及两个类：

newProxyInstance方法创建代理对象

//loader:被代理类的类加载器
//interfaces:被代理类实现的接口
//InvocationHandler:一个调用程序处理器，写增强的方法
public static Object newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h);

invoke方法

//obj指被代理类，method是被代理的方法，args为该方法的参数数组
public Object invoke(Object obj,Method method, Object[] args)

演示动态代理过程：(同上)

创建接口UserDao和实现类UserDaoImpl使用Proxy类创建接口代理对象

public class JdkProxy {

    public static void main(String[] args) {

        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao) Proxy.newProxyInstance(JdkProxy.class.getClassLoader(),interfaces,new UserDaoHandler(userDao));
        dao.add();
    }
}
class UserDaoHandler implements InvocationHandler{
    private Object obj;

    public UserDaoHandler(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("预处理");
        Object returnValue = method.invoke(obj, args);
        System.out.println("处理后");
        return returnValue;
    }
}

代码执行结果：

3.3 AOP相关术语

连接点：类中可以被增强的方法

切入点：类中实际被增强的方法，称为切入点

通知（增强）：实际增强的逻辑部分称为通知。

前置通知：要增强的方法之前执行后置通知：方法之后执行环绕通知：方法前后都执行异常通知：当方法出现异常执行最终通知：有无异常都执行，类似finally

切面：是动作。把通知应用到切入点的过程

3.4 AOP操作 3.4.1准备工作

Spring框架一般都是基于AspectJ实现AOP操作，可以通过xml或注解方式（使用）实现需要在项目工程里引入AOP相关依赖

切入点表达式：(指定对类中方法进行增强)

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

举例几个语法结构的例子
举例 1：对 com.zju.dao.BookDao 类里面的 add 进行增强
execution(* com.zju.dao.BookDao.add(..))

举例 2：对 com.zju.dao.BookDao 类里面的所有的方法进行增强
execution(* com.zju.dao.BookDao.* (..))

举例 3：对 com.zju.dao 包里面所有类，类里面所有方法进行增强
execution(* com.zju.dao.*.* (..))

3.4.2 AspectJ注解操作

1.在Spring配置文件中，开启注解扫描

2.使用注解创建被增强类User和增强的类UserProxy对象，在增强类上添加注解@Aspect

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

@Component
@Aspect //生成代理对象
public class UserProxy{
    //前置通知
    @Before
    public void before(){
        System.out.println("before...");
    }
}

3.在Spring配置文件中开启生成代理对象

，主要是查找注解@Aspect

4.配置不同的通知

在增强类里面，在作为通知方法上面添加通知类型注解，使用切入点表达式

//增强的类
@Component
@Aspect  //生成代理对象
@Order(3)
public class UserProxy {

    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* com.zju.aopanno.User.add(..))")
    public void before() {
        System.out.println("before.........");
    }

    //后置通知（返回通知），返回结果之后执行
    @AfterReturning(value = "execution(* com.zju.aopanno.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning.........");
    }

    //最终通知（无论是否异常都输出）
    @After(value = "execution(* com.zju.aopanno.User.add(..))")
    public void after() {
        System.out.println("after.........");
    }

    //异常通知，没异常不输出
    @AfterThrowing(value = "execution(* com.zju.aopanno.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing.........");
    }

    //环绕通知
    @Around(value = "execution(* com.zju.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前.........");

        //被增强的方法执行
        proceedingJoinPoint.proceed();

        System.out.println("环绕之后.........");
    }
}

ApplicationContext context =
    new ClassPathXmlApplicationContext("bean.xml");
User user = context.getBean("user", User.class);
user.add();//调用被代理对象会自动执行

相同切入点的抽取@Pointcut(value="execution( com.zju.aopanno.User.add(…))")*

//代理类
@Component
@Aspect
public class UserProxy {
    @Pointcut(value = "execution(* com.zju.proxyAnno.User.add(..))")
    public void pointCut(){

    }
    @Before(value = "pointCut()")
    public void before(){
        System.out.println("before...");
    }
}

有多个增强类多同一个方法进行增强，设置增强类优先级

在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高

@Component
@Aspect
@Order(1)

3.4.3 完全注解开发

生成配置类，代替xml配置

@Configuration //作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.zju.proxyAnno"})//开启组件扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)//开启Aspect生成代理对象,默认是true
public class SpringConfig {
}

3.4.4 AspectJ配置文件

1.创建两个类，增强类和被增强类，创建方法

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

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

2.在spirng配置文件中创建两个类对象、在spring配置文件中配置切入点

4. Jdbc Template

JdbcTemplate是Spring框架对JDBC进行封装，更方便实现对数据库操作

4.1 准备工作

引入依赖，在Spring配置文件配置数据库连接池

配置JdbcTemplate对象，注入DataSource

开启组件扫描，注解方式在dao注入JdbcTemplate，在service注入dao

@Autowired按类型注入，可以与@Qualifier按名称注入配合使用

@Resourse默认按名称注入，可同时指定名称name和类型type

IDEA不建议使用@Autowired

@Service
public class UserService {
    //注入dao
    @Resource
    private UserDao userDao;
}

@Repository
public class UserDaoImpl implements UserDao {

    @Resource
    private JdbcTemplate jdbcTemplate;

4.2 数据库添加

创建数据库表和数据库实体类

编写service和dao进行数据库添加操作

在service层和dao层添加add(User user)方法在dao层调用JdbcTemplate对象里面的jdbcTemplate.update(String sql, Object ... args)方法

@Repository
public class UserDaoImpl implements UserDao {
    @Resource
    private JdbcTemplate jdbcTemplate;

    @Override
    public void add(User user) {
        String sql = "insert into t_user values(?,?,?)";
        int update = jdbcTemplate.update(sql, null, user.getUserName(), user.getStatus());
        System.out.println(update);
    }
}

测试类：

@Test
public void testAdd(){
    ApplicationContext context =
        new ClassPathXmlApplicationContext("jdbc.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.addUser(new User(null,"fkd", "躺平"));
}

4.3 数据库修改与删除

方法同上:

数据库修改：

@Override
public void update(User user) {
    String sql = "update t_user set userName=?, status=? where user_id=?";
    int update = jdbcTemplate.update(sql,user.getUserName(),user.getStatus(),user.getUserId());
    System.out.println(update);
}

数据库删除

@Test
public void testDelete(){
    ApplicationContext context =
        new ClassPathXmlApplicationContext("jdbc.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.deleteUser(2);
}

4.4 数据库查询

1.查询返回某个值：

使用JdbcTemplate实现查询返回某个值：jdbcTemplate.queryForObject(String sql, Class requiredType)

第二个参数是返回类型的Class

@Override
public int selectCount() {
    String sql = "select count(*) from t_user";
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
    return count.intValue();
}

2.查询返回对象：

使用JdbcTemplate实现查询返回对象:jdbcTemplate.queryForObject(String sql, RowMapper rowMapper, Object ... args)

第二个参数RowMapper，是接口，返回不同类型对象。使用接口实现类BeanPropertyRowMapper(User.class)能够将查询到的数据封装到对象中。（类似BeanHandler）第三个参数是占位符的值

@Override
public User findUserInfo(Integer id) {
    String sql = "select `user_id` userId, `userName`, `status` form t_user where user_id = ?";
    User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper(User.class), id);
    return user;
}

注意：实体类User必须声明无参构造>

3.查询返回集合：

调用jdbcTemplate.query(String sql, RowMapper rowMapper, Object... args)会自动将查询到的数据封装到对象中，然后存到集合里

@Override
public List findAllUser() {
    String sql = "select `user_id` userId, `userName`, `status` form t_user";
    List userList = jdbcTemplate.query(sql, new BeanPropertyRowMapper(User.class));
    return userList;
}

4.5 数据库批量操作

1.批量添加:jdbcTemplate.batchUpdate(String sql, List batchArgs)

第二个参数batchArgs：List集合，每项是记录数据构成的对象数组方法底层会遍历，逐条添加

//批量添加
@Override
public void batchAddUser(List batchArgs) {
    String sql = "insert into t_user values(?,?,?)";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}

//批量添加测试
List batchArgs = new ArrayList<>();
Object[] o1 = {"2","sk","a"};
Object[] o2 = {"3","hhh","b"};
Object[] o3 = {"4","lyp","c"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用批量添加
userService.batchAdd(batchArgs);

2.批量修改

//批量修改
@Override
public void batchUpdateUser(List batchArgs) {
    String sql = "update t_user set userName=?,status=? where user_id=?";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}

3.批量删除

//批量删除
@Override
public void batchDeleteUser(List batchArgs) {
    String sql = "delete from t_user where user_id=?";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}

5.事务管理

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

例如：银行转账。

事务四个特性(ACID)

原子性(要么成功，要么失败，不可分割)一致性(数据保持一致)隔离性(互相不干扰)持久性

​ 事务一般添加到service层中，在Spring进行声明式事务管理，底层使用AOP原理

​ Spring提供一个接口，代表事务管理类，这个接口针对不同的框架提供不同的实现类

​ mybatis框架和JdbcTemplate用DataSourceTransactionManager实现类

5.1 转账事务：

创建数据库及相关表搭建service层和dao层，完成对象创建和属性注入

service注入dao，在dao注入JdbcTemplate，在JdbcTemplate注入DataSource

在service层加入转账方法，操作dao层数据库加钱和少钱

**问题：**如果业务逻辑层出现有一方错误，会出现一方成功一方失败的现象。

解决方案：事务

开启事务业务操作如果没有发生异常提交事务出现异常的话进行回滚 5.2 注解声明式事务管理

1.配置文件配置事务管理器

2.开启事务注解

引入名称空间tx，同上开启事务注解

3.在service类上或者该方法上添加事务注解@Transactional

如果把注解添加到类上面，表示这个类的所有方法都添加事务如果把注解放到方法上面，事务只是针对该方法

@Service
@Transactional
public class UserService {

---

@Transactional注解的参数配置:

propagation：事务传播行为

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

@Transactional(propagation = Propagation.REQUIRED)

举例说明：(add方法调用update方法)

​ REQUIRED(默认值):如果add有事务，调用update方法后，使用add方法事务；如果add没有事务，调用update后创建新事务

​ REQUIRED_NEW:无论add是否有事务，都创建新事务

isolation：事务隔离级别

事务并发必须设置隔离性以防止：脏读、不可重复读、幻读

（1）脏读：一个未提交事务读取到另一个未提交事务的数据（事件回滚，导致A读取B还未提交的事务，应该读取原始数据）-------不能容许

（2）不可重复读：一个未提交的事务，获取到了一个已经提交修改的事务（A读取B提交的事务，正常来说都提交了才能读取）------可以接受

（3）幻读：一个未提交的数据获取到了另一个事务添加数据

解决方案：设置事务的隔离性

事务情况	脏读	不可重复读	幻读
READ UNCOMMITTED(读未提交)	有	有	有
READ COMMITTED (读已提交)	无	有	有
REPEATABLE READ(可重复读)	无	无	有
SERIALIZABLE(串行化) 效率低	无	无	无

mysql默认：@Transactional(isolation = isolation.REPEATABLE_READ)

timeout：超时时间

（1）事务需要在一定时间内进行提交，如果不提交进行回滚
（2）默认值是timeout= -1 ，设置时间以秒单位进行计算

readOnly：是否只读

（1）读：查询操作，写：添加修改删除操作
（2）readonly 默认值 readonly = false，表示可以查询，可以添加修改删除操作
（3）设置 readonly 值是 true，设置成 true 之后，只能查询

rollbackFor：回滚

​ 设置出现哪些异常进行事务回滚

noRollbackFor：不回滚

​ 设置出现哪些异常不进行事务回滚

5.3 xml声明式事务管理

利用Aop将事务功能添加到指定类或方法上

必要准备:

第一步：配置事务管理器

第二步：配置通知

第三步：配置切入点和切入面

5.4 完全注解声明式事务管理

创建配置类：

使用set方法注入连接池属性，和Jdbc对象属性

@Bean:表示方法返回对象，然后对象交给IOC管理

@Configuration //配置类
@ComponentScan(basePackages = "com.transaction") //组件扫描
@EnableTransactionManagement //开启事务
public class TxConfig {

    //创建数据库连接池DruidDataSource
    @Bean
    public DruidDataSource getDruidDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///user_db");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        return dataSource;
    }

    //创建JdbcTemplate对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
        //到ioc容器中根据类型找到dataSource做注入
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    //创建事务管理器DataSourceTransactionManager
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource) {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

–>

第三步：配置切入点和切入面

```xml