Spring学习笔记

Luke Ewin

已于 2022-10-14 18:00:03 修改

阅读量688

点赞数 4

分类专栏： Spring 文章标签： spring 学习 java

于 2022-10-14 17:28:01 首次发布

本文链接：https://blog.csdn.net/qq_43907505/article/details/127323892

版权

Spring 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

1. Spring概述

是轻量级的开源的JavaEE框架
可以解决企业应用开发的复杂性
两个核心Aop/IOC
- Aop：切面编程，不修改源代码进行功能的增强
- IOC：控制反转，把创建对象过程交给Spring进行管理
Spring的特点
- 方便解耦，简化开发
- Aop编程支持
- 方便程序测试
- 方便整合其它框架
- 方便进行事务操作
- 降低API开发难度

2. IOC

把对象的创建和对象之间的调用过程都交给Spring进行管理

使用IOC目的：为了解耦

底层原理：xml解析、工厂模式、反射

在这里插入图片描述

IOC（接口）

IOC容器底层就是对象工厂
Spring提供IOC容器实现的两种方式（两个接口）
1. BeanFactory：IOC容器内置的基本实现，是Spring中内部使用的接口，不提供开发人员使用
2. ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般是开发人员使用
- 两种方式的区别：BeanFactory在加载配置文件的时候不会创建对象，在获取对象才去创建对象
- ApplicationContext在加载配置文件的时候就会把配置文件中的对象进行创建
ApplicationContext接口实现类

在这里插入图片描述

IOC操作Bean管理

什么是Bean管理
1. Spring创建对象
2. Spring注入属性
Bean管理操作有两种方式
1. 基于xml配置文件
2. 基于注解

IOC操作Bean管理（基于xml方式）

基于xml方式创建对象

在这里插入图片描述

在Spring配置文件中，使用bean标签，标签里面添加对应的属性
bean标签中常用的属性
1. id属性：给对象起一个唯一的标识
2. class属性：创建对象类的全路径（包类路径）
创建对象的时候默认执行无参构造

基于xml方式注入属性

DI：依赖注入，就是注入属性

第一种注入方式：使用setter

创建类，定义属性和对应的setter方法

public class Book {

    private String bname;

    private String bauthor;

    public void setBname(String bname) {
        this.bname = bname;
    }

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }
}

在Spring配置文件中配置对象创建，配置属性注入

在这里插入图片描述

第二种注入方式：使用有参构造
1. 创建有参构造方法
2. 向有参构造方法中注入属性

通过名称空间进行注入（了解），底层是setter注入

在这里插入图片描述

注入特殊值

在这里插入图片描述

注入外部bean

在这里插入图片描述

注入内部bean，级联关系

package top.lukeewin.spring5.bean;

/**
 * @author Luke Ewin
 * @create 2022-10-10 21:20
 */
public class Dept {

    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}

package top.lukeewin.spring5.bean;

/**
 * @author Luke Ewin
 * @create 2022-10-10 21:22
 */
public class Emp {

    private String ename;

    private String gender;

    private Dept dept;

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void add() {
        System.out.println(ename + "::" + gender + "::" + dept);
    }
}

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

    <!-- 内部bean -->
    <bean id="emp" class="top.lukeewin.spring5.bean.Emp">
        <property name="ename" value="lucy"/>
        <property name="gender" value="女"/>
        <!--设置对象-->
        <property name="dept">
            <bean id="dept" class="top.lukeewin.spring5.bean.Dept">
                <property name="dname" value="安保部"/>
            </bean>
        </property>
    </bean>
</beans>

级联的另外一种写发

	<!--级联赋值-->
    <bean id="emp" class="top.lukeewin.spring5.bean.Emp">
        <property name="ename" value="lucy"/>
        <property name="gender" value="女"/>
        <property name="dept" ref="dept"/>
    </bean>

    <bean id="dept" class="top.lukeewin.spring5.bean.Dept">
        <property name="dname" value="财务部"/>
    </bean>

级联的第三种方法

Emp类需要生成Dept的getter方法

	<!--级联赋值-->
    <bean id="emp" class="top.lukeewin.spring5.bean.Emp">
        <property name="ename" value="lucy"/>
        <property name="gender" value="女"/>
        <property name="dept" ref="dept"/>
        <property name="dept.dname" value="技术部"/>
    </bean>

    <bean id="dept" class="top.lukeewin.spring5.bean.Dept">
        <property name="dname" value="财务部"/>
    </bean>

注入集合类型属性

数组

		<property name="courses">
            <array>
                <value>Java</value>
                <value>MySQL</value>
            </array>
        </property>

list集合

        <property name="list">
            <list>
                <value>张三</value>
                <value>李四</value>
            </list>
        </property>

set集合

		<property name="sets">
            <set>
                <value>MySQL</value>
                <value>Redis</value>
            </set>
        </property>

map集合

		<property name="maps">
            <map>
                <entry key="JAVA" value="java"/>
                <entry key="PHP" value="php"/>
            </map>
        </property>

向集合中注入对象属性

在这里插入图片描述

把集合注入部分提取出来

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

在这里插入图片描述

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

在这里插入图片描述

两种bean

普通bean和工厂bean

在这里插入图片描述

工厂bean

<bean id="myBean" class="top.lukeewin.spring5.factorybean.MyBean"></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;
    }
}

	@Test
    public void test3() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
        Course course = context.getBean("myBean", Course.class);
        System.out.println(course);
    }

在这里插入图片描述

Bean的作用域

Bean的作用域包含：singleton,prototype,session,application

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

prototype，表示是多实例对象

Bean的生命周期

从对象的创建到对象的销毁的过程

Bean的生命周期：

通过构造器创建bean实例（调用无参构造方法）
为bean的属性设置值和对其它bean的引用（调用setter方法）
把bean实例传递到bean的后置处理器的方法postProcessBeforeInitialization
调用bean的初始化方法（需要在配置文件中进行配置初始化方法）
把bean实例传递到bean后置处理器的方法postProcessAfterInitialization
bean可以使用了（获取对象）
当容器关闭时，调用bean的销毁方法（需要在配置文件中配置销毁方法）

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.xml中配置====

运行结果：

在这里插入图片描述

IOC操作Bean管理（xml自动装配）

什么是自动装配？

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

根据属性名称自动注入

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

根据属性类型自动注入

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

总结：

bean标签中的autowire=“byName”实现按照属性名称进行自动装配，注入值 bean 的 id 值和类属性名称一样

bean标签中的autowire=“byType”实现按照属性类型进行自动装配

IOC操作Bean管理（外部属性文件）

直接配置数据源

<!--直接配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
 <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
 <property name="url"
value="jdbc:mysql://localhost:3306/userDb"></property>
 <property name="username" value="root"></property>
 <property name="password" value="root"></property>
</bean>

引入外部配置数据源

需要先引入druid依赖

然后定义外部数据源

在这里插入图片描述

最后把jdbc.properties文件引入到bean.xml配置文件中，需要先引入context名称空间

<!--引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--配置连接池-->
<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>

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

什么是注解？

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

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

（3）使用注解目的：简化 xml 配置
Spring 针对 Bean 管理中创建对象提供注解

（1）@Component

（2）@Service

（3）@Controller

（4）@Repository

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

基于注解方式实现对象的创建过程

引入aop依赖

开启组件扫描

<context:component-scan base-package="top.lukeewin"></context:component-scan>

如果需要扫描多个包，可以使用逗号分隔开

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

//在注解里面 value 属性值可以省略不写，
//默认值是类名称，首字母小写
//UserService -- userService
@Component(value = "userService") //<bean id="userService" class=".."/>
public class UserService {
     public void add() {
     	System.out.println("service add.......");
     }
}

开启组件扫描的细节

use-default-filters=“false” 表示现在不使用默认 filter，自己配置 filter context:include-filter ，设置扫描哪些内容

<context:component-scan base-package="top.lukeewin" use-defaultfilters="false">
 	<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

下面配置扫描包所有内容 context:exclude-filter：设置哪些内容不进行扫描

<context:component-scan base-package="top.lukeewin">
 	<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

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

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

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

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

@Service
public class UserService {
     //定义 dao 类型属性
     //不需要添加 set 方法
     //添加注入属性注解
     @Autowired
     private UserDao userDao;
     public void add() {
         System.out.println("service add.......");
         userDao.add();
     }
}

（2）@Qualifier：根据名称进行注入这个@Qualifier 注解的使用，和上面@Autowired 一起使用

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

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

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

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

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

完全注解开发

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

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

编写测试类

注意：这里创建的是AnnotationConfigApplicationContext对象

@Test
public void testService2() {
 //加载配置类
 ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
 UserService userService = context.getBean("userService", UserService.class);
 System.out.println(userService);
 userService.add();
}

3. AOP

什么是AOP

面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而降低各个部分之间的耦合度，提高了程序的可用性，同时也能提高开发效率
不用修改源代码，在主干程序中添加新的功能
使用登录例子说明AOP

AOP底层原理

AOP底层使用动态代理，有两种动态代理：JDK动态代理和CGLIB动态代理

对于被增强类有接口的情况下，可以使用JDK动态代理

对于被增强类没有接口的情况下，使用CGLIB动态代理

在这里插入图片描述

JDK动态代理和CGLIB动态代理

JDK动态代理需要要求被代理类至少实现一个接口。同时代理类还需要实现InvocationHandler接口，重写invoke()，使用Proxy.newProxyInstance()产生代理对象

CGLIB动态代理要求被代理的方法不能被final修饰

下面是JDK动态代理代码：

package top.lukeewin.spring5.proxydemo;

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

// 代理类必须实现InvocationHandler
public class JDKProxy implements InvocationHandler {

    private Object obj;

    // 通过有参构造把真实的对象注进来
    public JDKProxy(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("洗手");
        Object res = method.invoke(obj);
        System.out.println("放好餐具");
        return res;
    }
}

interface Person {
    void eat();
}

// 被代理类
class Student implements Person {

    // 要被增强的方法
    @Override
    public void eat() {
        System.out.println("学生吃饭");
    }
}

class TestProxy {
    public static void main(String[] args) {
        Student student = new Student();
        Person proxyInstance = (Person) Proxy.newProxyInstance(Student.class.getClassLoader(), Student.class.getInterfaces(), new JDKProxy(student));
        proxyInstance.eat();
    }
}

CGLIB动态代理：

package top.lukeewin.spring5.proxydemo;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CGLIBProxy implements MethodInterceptor {

    private Object obj;

    // 通过有参构造把真实的对象注进来
    public CGLIBProxy(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("猫吃食物之前");
        Object res = method.invoke(obj, objects);
        System.out.println("猫吃食物之后");
        return res;
    }
}

class Cat {

    public void eat(String food) {
        System.out.println("猫吃" + food);
    }
}

class TestCGLIBDemo {
    public static void main(String[] args) {
        Cat cat = new Cat(); // 创建被增强类对象
        CGLIBProxy cglibProxy = new CGLIBProxy(cat); // 创建增强类对象
        Cat c = (Cat) Enhancer.create(cat.getClass(), cglibProxy);
        c.eat("老鼠");
    }
}

AOP术语

连接点：类里面可以被增强的方法（并不是所有方法都可以被增强，例如使用CGLIB动态代理时，不能增强final方法）
切入点：实际上要被增强的方法
通知（增强）：实际增强的逻辑部分
1. 通知分为以下几类：
  - 前置通知（before）
  - 后置通知（after）
  - 环绕通知（aroud）
  - 异常通知（afterThrowing）
  - 最终通知（返回通知）（afterReturing）
2. 需要注意不同通知的执行顺序。先执行环绕通知，然后是前置通知。没有异常时的执行顺序：环绕之前，前置通知，被增强方法，环绕之后，后置通知，最终通知。有异常情况：环绕之前，前置通知，后置通知，异常通知。无论发没发生异常都会执行后置通知
切面：把通知应用到切点的过程

通知（基于全注解）

创建配置类

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true) // 开启AspectJ
@ComponentScan(basePackages = "top.lukeewin.spring5.aop")
public class SpringConfig {

}

创建被增强类

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

创建增强类

@Component
@Aspect
public class AspectJProxy {

    @Before(value = "execution(* top.lukeewin.spring5.aop.User.add(..))")
    public void before() {
        System.out.println("before......");
    }

    @After(value = "execution(* top.lukeewin.spring5.aop.User.add(..))")
    public void after() {
        System.out.println("after......");
    }

    @Around(value = "execution(* top.lukeewin.spring5.aop.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("around before......");
        proceedingJoinPoint.proceed();
        System.out.println("around after......");
    }

    @AfterThrowing(value = "execution(* top.lukeewin.spring5.aop.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing......");
    }

    @AfterReturning(value = "execution(* top.lukeewin.spring5.aop.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning......");
    }
}

测试类

public class TestAspectJ {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        User user = (User) context.getBean("user");
        user.add();
    }
}

运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2Vxnlk72-1665737854085)(Spring学习笔记.assets/image-20221012184217805.png)]

如果被增强的方法有异常，则结果如下：

在这里插入图片描述

结论：如果没有异常时，执行的顺序为：环绕通知，前置通知，被增强方法，后置通知，后置返回通知

如果有异常，则执行顺序为：环绕通知，前置通知，后置通知，异常通知

通知（基于配置文件）

如果不是全注解的方式，配合xml配置文件的方式，则配置文件如下：

<?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"
       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="top.lukeewin.spring5.aop"/>
    
    <!-- 开启Aspectj注解 -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
    
</beans>

出测试类外，其它的类不变，测试类如下：

public class TestAspectJDemo {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        User user = (User) context.getBean("user");
        user.add();
    }
}

如果是完全基于xml配置文件的方式，则如下：

<!--配置 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>

抽取相同的切入点

// 抽取相同的切入点
// 切点表达式格式：访问修饰符 返回值 包名.类名.方法名(参数列表)
// 访问修饰符可以省略
@Pointcut("execution(* top.lukeewin.spring5.aop.User.add(..))")
public void pointCut() {

}

// 引入切点表达式
@Before(value = "pointCut()")
public void before() {
	System.out.println("before......");
}

如果有多个类对同一个类中的方法增强，则需要设定优先级，使用@Order(数值)来设置，数值越小，优先级越高，就越先执行。

4. JdbcTemplate

JdbcTemplate准备工作

先要引入相关的依赖

在这里插入图片描述

编写jdbc.properties配置文件

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test?serverTimezone=Asia/Shanghai
jdbc.username=root
jdbc.password=XRXxrx123

编写bean.xml配置文件

<?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:component-scan base-package="top.lukeewin.spring5"/>

    <!-- 读取jdbc.properties文件 -->
    <context:property-placeholder location="jdbc.properties"/>

    <!-- 生成数据源对象 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!-- 生成JdbcTemplate对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 向jdbcTemplate对象中的dataSource属性注入值 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

JdbcTemplate添加操作

编写实体类

public class Book {

    private Integer id;

    private String name;

    private float price;

    private Date time;

    public Book() {
    }

    public Book(Integer id, String name, float price, Date time) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.time = time;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    public Date getTime() {
        return time;
    }

    public void setTime(Date time) {
        this.time = time;
    }
}

编写Dao接口

public interface BookDao {
    void add(Book book);
}

编写Dao接口的实现类

@Repository
public class BookDaoImpl implements BookDao {

    // 注入jdbcTemplate对象
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void add(Book book) {
        String sql = "insert into books(name, price, time) values(?,?,?)";
        Object[] args = {book.getName(), book.getPrice(), book.getTime()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }
}

编写Service类，这里省略了编写Service接口

@Service
public class BookService {

    // 注入Dao
    @Autowired
    private BookDao bookDao;

    public void add(Book book) {
        // 调用Dao中的方法
        bookDao.add(book);
    }
}

编写测试类

public class JdbcTemplateDemo {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml"); // 解析xml配置文件
        BookService bookService = context.getBean("bookService", BookService.class); // 从IOC容器中获取bookService对象
        Book book = new Book();
        book.setName("PHP");
        book.setPrice(25.5f);
        book.setTime(new Date());
        bookService.add(book);
    }
}

JdbcTemplate修改操作

	@Override
    public void updateBook(Book book) {
        String sql = "update books set name = ?, price = ? where id = ?";
        Object[] args = {book.getName(), book.getPrice(),book.getId()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

JdbcTemplate删除操作

	@Override
    public void deleteBook(int id) {
        String sql = "delete from books where id = ?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }

JdbcTemplate查询操作

查询返回某个数

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

返回单个对象

	@Override
    public Book findBookById(int id) {
        String sql = "select * from books where id = ?";
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
        return book;
    }

总结：添加、删除、修改都是调用jdbcTemplate.update()方法，查询则调用jdbcTemplate.queryForObject()方法

查询中第二个参数填RowMapper接口的实现类，这里写BeanPropertyRowMapper<>()，泛型填写要封装到哪个类，参数填写要封装类的字节码文件

返回一个集合

	@Override
    public List<Book> findAllBooks() {
        String sql = "select * from books";
        List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
        return bookList;
    }

JdbcTemplate批量操作

批量添加

在这里插入图片描述

批量删除

在这里插入图片描述

批量修改

在这里插入图片描述

5. 事务

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

事务的四大特性：ACID

原子性
一致性
隔离性
持久性

事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）

在Spring中有两种方式进行事务操作：编程式事务管理和声明式事务管理（使用）

声明式事务管理分为：基于xml配置文件方式和基于注解方式（开发中常用）

基于注解方式的声明式事务管理

在 Spring 进行声明式事务管理，底层使用 AOP 原理

编写配置文件

<?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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 开启组件扫描 -->
    <context:component-scan base-package="top.lukeewin.spring5"/>

    <!-- 读取jdbc.properties文件 -->
    <context:property-placeholder location="jdbc.properties"/>

    <!-- 生成数据源对象 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!-- 生成JdbcTemplate对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 向jdbcTemplate对象中的dataSource属性注入值 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>

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

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

核心部分

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

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

在Service中添加@Transactional注解，可以添加到类上，也可以添加到方法方法

	// 添加
    @Transactional
    public void add(Book book) {
        // 调用Dao中的方法
        bookDao.add(book);
        int a = 10 / 0;
    }

在这里插入图片描述

事务传播行为（重点理解）

Spring在TransactionDefinition接口中规定了7种类型的事务传播行为

事务传播行为是Spring框架独有的事务增强特性

required / supports / mandatory / requires_new / not supported / never / nested

required需要，没有新建，有加入，Spring中的事务默认为required
supports支持，有则加入，没有就不管了，非事务运行
mandatory强制性，有则加入，没有异常
requires_new需要新的，不管有没有，直接创建新事务
not supported不支持事务，存在就挂起
never不支持事务，存在就异常
nested存在就在嵌套的执行，没有就找是否存在外面的事务，有则加入，没有则新建

参考文档

事务隔离级别（重点理解）

事务的四大特性分别是：原子性、一致性、隔离性、持久性

由四大特性引出的三个问题：脏读、不可重复读、幻读

脏读（读取未提交数据）

A事务读取B事务尚未提交的数据，此时如果B事务发生错误并执行回滚操作，那么A事务读取到的数据就是脏数据。就好像原本的数据比较干净、纯粹，此时由于B事务更改了它，这个数据变得不再纯粹。这个时候A事务立即读取了这个脏数据，但事务B良心发现，又用回滚把数据恢复成原来干净、纯粹的样子，而事务A却什么都不知道，最终结果就是事务A读取了此次的脏数据，称为脏读。
不可重复读（前后多次读取，数据内容不一致）

事务A在执行读取操作，由整个事务A比较大，前后读取同一条数据需要经历很长的时间。而在事务A第一次读取数据，比如此时读取了小明的年龄为20岁，事务B执行更改操作，将小明的年龄更改为30岁，此时事务A第二次读取到小明的年龄时，发现其年龄是30岁，和之前的数据不一样了，也就是数据不重复了，系统不可以读取到重复的数据，成为不可重复读。
幻读（前后多次读取，数据总量不一致）

事务A在执行读取操作，需要两次统计数据的总量，前一次查询数据总量后，此时事务B执行了新增数据的操作并提交后，这个时候事务A读取的数据总量和之前统计的不一样，就像产生了幻觉一样，平白无故的多了几条数据，成为幻读。

四种隔离级别
1. Read uncommitted 读未提交（一个事务可以读取另一个未提交事务的数据）
2. Read committed 读已提交（一个事务要等另一个事务提交后才能读取数据）解决脏读问题 Oracle默认级别
3. Repeatable read 重复读（在开始读取数据（事务开启）时，不再允许修改操作）解决不可重复读 MySQL默认级别
4. Serializable 序列化 解决脏读、不可重复读、幻读情况
参考资料

完全注解声明式事务管理

配置类

@Configuration //配置类
@ComponentScan(basePackages = "top.lukeewin") //组件扫描
@EnableTransactionManagement //开启事务
public class TxConfig {
     //创建数据库连接池
     @Bean
     public DruidDataSource getDruidDataSource() {
         DruidDataSource dataSource = new DruidDataSource();
         dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
         dataSource.setUrl("jdbc:mysql://localhost:3306/test?serverTimezone=Asia/Shanghai");
         dataSource.setUsername("root");
         dataSource.setPassword("root");
         return dataSource;
     }
     //创建 JdbcTemplate 对象
     @Bean
     public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
         //到 ioc 容器中根据类型找到 dataSource
         JdbcTemplate jdbcTemplate = new JdbcTemplate();
         //注入 dataSource
         jdbcTemplate.setDataSource(dataSource);
         return jdbcTemplate;
     }
     //创建事务管理器
     @Bean
     public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource) {
         DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
         transactionManager.setDataSource(dataSource);
         return transactionManager;
     }
}

基于xml配置文件声明式事务管理

<!--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(* top.lukeewin.spring5.service.UserService.*(..))"/>
     <!--配置切面-->
     <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>

能坚持阅读到最后的一定是铁粉了，感谢你的阅读，更多内容也可以访问我的个人博客

Luke Ewin

关注

4
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
Spring学习笔记

整理尚硅谷的Spring教程，融合自己的理解做的笔记，该笔记讲述Spring的IOC和AOP以及事务等功能。Spring作为Java EE轻量级开源框架，深受广大Java开发者的爱好，Spring是Java程序员的必经之路。
复制链接

扫一扫