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配置文件，配置创建的对象

<bean id="dao" class"com.zju.UserDao"></bean>

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

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标签添加对应属性即可实现对象创建

<bean id="dao" class"com.zju.UserDao"></bean>

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

​ class：类全路径

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

2.3.2 xml方式注入基本属性

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

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

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

<bean id="user" class="com.zju.User">
    <!--使用property完成属性注入，
            name:类里面属性名称
            value:注入的值
        -->
    <property name="name" value="fkd"></property>
    <property name="city" value="NingBo"></property>
</bean>

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

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

<bean id="orders" class="com.zju.Orders">
	<constructor-arg name="oname" value="电脑"></constructor-arg>
	<constructor-arg name="address" value="China"></constructor-arg>
</bean>

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

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       
       xmlns:p="http://www.springframework.org/schema/p"
          <bean id="book" class="com.atguigu.spring5.Book" p:bname="九阳神功" p:bauthor="无名氏">
</bean>

2.3.3 xml注入其他类型属性

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

• null值

<property name = "address">
	<null/>
</property>

• 包含特殊符号

<!--1.把<>转义为&lt;&gt;
	2.把带特殊符号的内容写到CDATA(IDEA输入CD)
-->
<property name = "address">
    <value><![CDATA[<<南京>>]]></value>
</property>

​ 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

<!--首先分别创建两个类对象，再注入对象属性-->
<bean id="userService" class="com.zju.service.UserService">
    <!--注入userDao对象
        name属性：类里面属性名称
        ref属性：创建userDao对象bean标签id值
    -->
    <property name="userDao" ref="userDaoImpl"></property>
</bean>

<bean id="userDaoImpl" class="com.zju.dao.UserDaoImpl"></bean>

​ 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 id="emp" class="com.zju.bean.Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>
    <!--设置对象类型属性-->
    <property name="dept">
        <bean id="dept" class="com.zju.bean.Dept">
            <property name="dname" value="安保部"></property>
        </bean>
    </property>
</bean>

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

​ 4.注入属性级联赋值

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

<bean id="emp" class="com.zju.bean.Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>
    <!--级联赋值-->
    <property name="dept" ref="dept"></property>

</bean>
<bean id="dept" class="com.zju.bean.Dept">
    <property name="dname" value="财务部"></property>
</bean>

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

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

<bean id="emp" class="com.zju.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="com.zju.bean.Dept"></bean>

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

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

• 调用对象模板

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

（1）注入数组类型属性

<property name="courses">
    <array>
        <value>java课程</value>
        <value>数据库课程</value>
    </array>
</property>

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

<!--list类型属性注入-->
<property name="list">
    <list>
        <value>张三</value>
        <value>小三</value>
    </list>
</property>

（3）注入Set集合属性

!--set类型属性注入-->
<property name="sets">
    <set>
        <value>MySQL</value>
        <value>Redis</value>
    </set>
</property>

（4）注入map集合属性

<!--map类型属性注入-->
<property name="maps">
    <map>
        <entry key="JAVA" value="java"></entry>
        <entry key="PHP" value="php"></entry>
    </map>
</property>

注意点：

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

<bean id="stu" class="com.zju.collectiontype.Stu">
    <property name="courseList">
        <list>
            <!--bean属性放入外部id值-->
        	<ref bean="course1"></ref>
            <ref bean="course2"></ref>
        </list>
    </property>
</bean>
<!--外部创建多个course对象-->
<bean id="course1" class="com.zju.Collectiontype.Course">
	<property name="cname" value="Spring5"></property>
</bean>

<bean id="course2" class="com.zju.Collectiontype.Course">
	<property name="cname" value="SpringMVC"></property>
</bean>

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

• 使用util的名称空间注入

<?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: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">   //修改部分
    <!--1.提取list集合类型公共部分-->
    <util:list id="bookList">
        <value>斗破苍穹</value>
        <value>斗罗大陆</value>
        <value>吞噬星空</value>
    </util:list>
    <!--2.公共部分注入使用-->
    <!--需要注入的类-->
    <bean id="book" class="com.zju.Book">
        <property name="list" ref="bookList"></property>
    </bean>
</beans>

2.4 工厂bean

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

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

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

public class MyBean implements FactoryBean<Course> {

    //定义返回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:

<bean id="myBean" class="com.zju.factorybean.MyBean">
</bean>

此时调用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

<bean id="book" class="com.zju.Book" scope="prototype">
    <property name="list" ref="bookList"></property>
</bean>

区别：

• 设置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，指定初始化方法和销毁方法

<bean id="orders" class="com.atguigu.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
    <property name="oname" value="手机"></property>
</bean>

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;
    }
}

<!--配置后置处理器-->
<bean id="myBeanPost" class="com.zju.bean.MyBeanPost"></bean>

2.7 xml自动装配

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

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

<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName">
  <!--<property name="dept" ref-id="dept"></property>-->
</bean>

<bean id="dept"class="com.atguigu.spring5.autowire.Dept"></bean>

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

<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType">
</bean>

<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
<bean id="dept1" class="com.atguigu.spring5.autowire.Dept"></bean>

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

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配置文件使用标签引入外部属性文件

<!--引入外部属性文件,classPath是src路径-->
<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

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

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

注解是什么？

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

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

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

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

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

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

<!--开启组件扫描
 1 如果扫描多个包，多个包使用逗号隔开
 2 扫描包上层目录
-->
<context:component-scan base-package="com.zju"></context:component-scan>

开启组件扫描详细配置：

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

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

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

type只扫描这种注解类

expression表示扫描的为该注解类

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

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

<context:component-scan base-package="com.zju" use-defaultfilters="false">
 <context:include-filter type="annotation"

                         expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

• 第三步：创建类，在类上添加创建对象注解(四选一)
  • 在注解里面value属性值可以省略不写,默认值是类名称，改首字母小写

//UserService -- userService
//@Component(value = "userService")  //<bean id="userService" class=".."/>
@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;

/**
 * @author godfu
 * @Date:2022/3/25-10:32
 */
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{
    /**
     * 传入被代理对象调用此方法返回代理类对象，解决问题一
     * @param obj 被代理类对象
     * @return 代理类类型
     */
    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类创建接口代理对象

/**
 * UserDao的代理类，进行功能扩充
 */
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配置文件中，开启注解扫描

<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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
                        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!-- 开启注解扫描 -->
    <context:component-scan base-package="com.zju.aopanno"></context:component-scan>

    <!-- 开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

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配置文件中开启生成代理对象

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>，主要是查找注解@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配置文件中配置切入点

<!--创建对象-->
<bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>

<!--配置aop增强-->
<aop:config>
    <!--切入点-->
    <aop:pointcut id="p" expression="execution(* com.atguigu.spring5.aopxml.Book.buy(..))"/>
    <!--配置切面-->
    <aop:aspect ref="bookProxy">
        <!--增强作用在具体的方法上-->
        <aop:before method="before" pointcut-ref="p"/>
    </aop:aspect>
</aop:config>

4. Jdbc Template

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

4.1 准备工作

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

• 配置JdbcTemplate对象，注入DataSource

<!-- JdbcTemplate对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入dataSource-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

• 开启组件扫描，注解方式在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<T> 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<T> rowMapper, Object ... args)
  • 第二个参数RowMapper，是接口，返回不同类型对象。使用接口实现类BeanPropertyRowMapper<User>(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>(User.class), id);
    return user;
}

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

3.查询返回集合：

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

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

4.5 数据库批量操作

1.批量添加:jdbcTemplate.batchUpdate(String sql, List<Object[]> batchArgs)

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

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

//批量添加测试
List<Object[]> 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<Object[]> 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<Object[]> 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.配置文件配置事务管理器

<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

2.开启事务注解

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

<!--开启事务注解-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

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将事务功能添加到指定类或方法上

必要准备:

<!-- 组件扫描 -->
<context:component-scan base-package="com.atguigu"></context:component-scan>

<!-- 数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
      destroy-method="close">
    <property name="url" value="jdbc:mysql:///user_db" />
    <property name="username" value="root" />
    <property name="password" value="root" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>

<!-- JdbcTemplate对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入dataSource-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

第一步：配置事务管理器

<!--1 创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

第二步：配置通知

<!--2 配置通知-->
<tx:advice id="txadvice">
    <!--配置事务参数-->
    <tx:attributes>
        <!--指定哪种规则的方法上面添加事务-->
        <tx:method name="accountMoney" propagation="REQUIRED"/>
        <!--<tx:method name="account*"/>-->
    </tx:attributes>
</tx:advice>

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

<!--3 配置切入点和切面-->
<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="pt" expression="execution(* com.atguigu.spring5.service.UserService.*(..))"/>
    <!--配置切面-->
    <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>

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;
    }
}

–>
</tx:attributes>
</tx:advice>

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

```xml
<!--3 配置切入点和切面-->
<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="pt" expression="execution(* com.atguigu.spring5.service.UserService.*(..))"/>
    <!--配置切面-->
    <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>