spring5框架

概述：

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

IOC容器

概念：控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理
目的：为了耦合度降低

IOC底层原理：

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

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

BaeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供给开发人员进行使用。加载配置文件文件时不会创建对象，在获取对象（使用）才去创建对象。
ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员使用。加载配置文件时候会把在配置文件对象进行创建

IOC操作Bean管理（基于XML）

创建对象（在ApplicationContext.xml中添加如下内容)

<!--配置User对象创建-->
<bean id="user" class="com.ls.User"></bean>

说明：

在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
在bean标签有很多属性，介绍常用属性：id属性：唯一标识，class属性：类全路径（包类路径），name属性：和id作用一样，可以写符号
创建对象时候，默认执行无参数构造方法，完成对象的创建

注入属性（DI:依赖注入，注入属性）

使用set方式注入

	<!--配置User对象创建-->
	<bean id="user" class="com.ls.User"></bean>
	<!-- set方法注入属性 -->
	<bean id="book" class="com.ls.Book">
	<!--使用property完成属性注入-->
	<property name="属性名" value="属性值"></property>
	</bean>

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

<!-- 有参构造注入属性 -->
<bean id="orders" class="com.ls.Orders">
<constructor-arg name="属性" value="属性值"></constructor-arg>
<constructor-arg index="索引值" value="属性值"></constructor-arg>
</bean>

使用p命名空间：
在配置文件中添加：

<bean id="book" class="com.ls.Book" p:属性名="属性值"/>

xml中注入其他类型
字面量：

null值

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

属性值包含特殊符号把<>进行转义 <或> 把带特殊符号内容写到CDATA中
注入属性外部bean

<bean id="userService" class="com.ls.service.Userservice">
<!--        注入userDao对象-->
<!--            name属性：类里面属性名称-->
<!--            ref属性：创建userDao对象bean标签id值-->
<property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.ls.dao.UserDaoImpl"></bean>

内部bean和级联赋值（以员工和部门为例，一个部门对应多个员工）

//实体类
public class Dept {
	String DName;

	public void setDName(String DName) {
		this.DName = DName;
	}
}
public class Emp {
	String EName;
	String EGender;
	Dept dept;

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

	public void setEName(String EName) {
		this.EName = EName;
	}

	public void setEGender(String EGender) {
		this.EGender = EGender;
	}
}

在application中的配置：

<!-- 内部bean-->
<bean id="emp" class="com.ls.bean.Emp">
	<!-- 设置两个普通属性-->
	<property name="EName" value="lucy"></property>
	<property name="EGender" value="女"></property>
	<!-- 设置对象类型属性-->
	<property name="dept">
		<bean id="dept" class="com.ls.bean.Dept">
			<property name="DName" value="安保部"></property>
		</bean>
	</property>
</bean>

<!-- 内部bean-->
<bean id="emp" class="com.ls.bean.Emp">
	<!-- 设置两个普通属性-->
	<property name="EName" value="lucy"></property>
	<property name="EGender" value="女"></property>
	<property name="dept" ref="dept"></property>
	<!-- <property name="dept.name" value="技术部"></property>此方式需要有该对象的get方法-->
</bean>
<bean id="dept" class="com.ls.bean.Dept">
	<property name="dname" value="财务部"></property>
</bean>

xml注入集合等属性

public class Stu {
	//1.数组类型属性
	private String[] courses;

	//2.list集合类型属性
	private List<String> list;

	//3.map集合类型属性
	private M ap<String,String> maps;

	public void setCourses(String[] courses) {
		this.courses = courses;
	}

	public void setList(List<String> list) {
		this.list = list;
	}

	public void setMaps(Map<String, String> maps) {
		this.maps = maps;
	}

	public Stu() {
	}
}

application中的配置

<bean id="stu" class="com.ls.bean.Stu">
	<property name="courses">
		<array>
			<value>Java</value>
			<value>mysql数据库</value>
		</array>
	</property>
	<property name="list">
		<list>
			<value>list1</value>
			<value>list2</value>
		</list>
	</property>
	<property name="maps">
		<map>
			<entry key="java" value="java"></entry>
			<entry key="pHp" value="pHp"></entry>
		</map>
	</property>
</bean>

集合提取的 application配置：1. 在spring配置文件中引入名称空间util 2. 使用util标签完成list集合注入提取

<!-- 提取集合类型属性注入-->
<util:list id="bookList">
	<value>Java</value>
	<value>python</value>
</util:list>
<!--提取list集合类型属性注入使用 -->
<bean id="book" class="com.ls.Book">
	<property name="list" ref="bookList"></property>
</bean>

IOC操作Bean管理（FactoryBean）

Spring 有两种类型bean，一种普通bean，另外一种工厂bean（FactoryBean）
普通bean:在配置文件中定义bean类型就是返回类型。
工厂bean：在配置文件定义bean 类型可以和返回类型不一样。
第一步创建类，让这个类作为工厂bean，实现接口FactoryBean
第二步实现接口里面的方法，在实现的方法中定义返回的bean的类型
代码演示：

<bean id="MyBean" class="com.ls.factorybean.MyBean">

</bean>

public class Account implements Serializable {

    private Integer id;
    private String name;
    private Double money;

    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 Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

public class MyBean implements FactoryBean<Account> {

    //定义返回bean
    @Override
    public Account getObject() throws Exception {
        Account account = new Account();
        account.setId(123);
        return account;
    }
    //
    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

//测试
ctx.getBean("MyBean",Account.class);

IOC操作Bean管理（bean作用域）

在Spring里面，设置创建bean实例是单实例还是多实例。
在Spring里面，默认情况下，bean是一个单实例对象。
如何设置单实例还是多实例
在spring配置文件bean标签里面有属性（scope）用于设置单实例还是多实例：
第一个值，singleton，表示是单实例的，加载配置文件时，就会创建一个单实例对象
第二个值，prototype，表示是多实例的，不是在加载spring配置文件对象创建对象，在调用getBean方法时，创建多实例对象
request 放入web的request中
session 仿佛web的session中

IOC操作bean管理(bean的生命周期)

1. 生命周期

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

2.bean的生命周期

通过构造器创建bean实例（无参数构造）
为bean的属性设置值和对其他bean的引用(调用set方法)
调用bean 的初始化的方法（需要进行配置）
bean可以使用了（对象获取到了）
当容器关闭时候，调用bean的销毁方法（需要进行配置销毁方法）

3.演示bean的生命周期

public class Orders {
     private  String oName;

    public Orders() {
        System.out.println("第一步执行无参构方法");
    }

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

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

    //创建执行的销毁方法
    public void destroyMethod(){
        System.out.println("第五步 执行销毁方法");
    }
}
//main方法中
//        ApplicationContext ctx1 = new ClassPathXmlApplicationContext("bean4.xml");
        ClassPathXmlApplicationContext ctx1 = new ClassPathXmlApplicationContext("bean4.xml");

        Orders orders = (Orders) ctx1.getBean("orders");
        System.out.println("第四步 获取创建bean的对象");
        System.out.println(orders);
        //手动让bean 实例销毁
        ctx1.close();

配置文件：

<?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"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/util
        https://www.springframework.org/schema/util/spring-util.xsd">

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

    <bean id="orders" class="com.ls.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oName" value="张三"></property>
    </bean>
</beans>

4.bean的后置处理器，bean的生命周期有七步

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

5.演示后置处理器效果

创建类，实现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="orders" class="com.ls.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oName" value="张三"></property>
    </bean>
    <!-- 配置后置处理器 -->
    <bean id="myBeanPost" class="com.ls.bean.MyBeanPost">
    </bean>

后置处理器会为所有注入的类都添加后置处理器

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

1.什么是自动装配

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

2.演示自动装配过程

根据属性名称自动注入
根据属性类型自动注入

<!-- 实现自动装配
        bean标签autowire,配置自动装配
        autowire属性常用两个值，
        byName根据属性名称进行注入,注入值的id值和类属性名称一样
        byType 根据属性类型进行注入，
     -->
    <bean id="emp" class="com.ls.autowire.Emp" autowire="byName">
<!--        <property name="dept" ref="dept"></property>-->
    </bean>
    <bean id="dept" class="com.ls.autowire.Dept">
    </bean>

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

1、直接配置数据库信息

配置德鲁伊连接池

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

引入德鲁伊连接池依赖

<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>druid</artifactId>
	<version>1.1.16</version>
</dependency>

2.引入外部属性文件配置数据库的连接池

<?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"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/util
        https://www.springframework.org/schema/util/spring-util.xsd">
 <context:property-placeholder location="classpath:*.properties"/>

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

    <bean id="accountService" class="com.ls.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
        <!--<property name="dataSource" ref="dataSource"/>-->
    </bean>

    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.ls.domain"/>
    </bean>

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.ls.dao"/>
    </bean>
</beans>

6. IOC操作Bean管理（基于注解）

1.什么是注解

注解是代码特殊标记，格式：@注解名称(属性名称=属性值,属性名称=属性值...)
使用注解，注解作用在类上面，方法上面，属性上面
使用注解目的：简化xml配置。

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

@Component
@Service
@Controller
@Repository

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

3.基于注解方式创建对象和注入属性

添加环境依赖
开启组件扫描(如果扫描多个包，多个包使用逗号隔开)

<context:component-scan base-package="com.ls"></context:component-scan>

创建类，在类上添加注解、

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

开启组件细节扫描(use-default-filters="false"表示现在不适用默认filter,自己配置filter context:include-filter,设置扫描那些内容,<context:exclude-filter type="annotation" 不去扫描那些内容)

<context:component-scan base-packag="com.ls" use-default-filters="false">
	<context:include-filter type="annotation"
		expression="org.springframework.stereotype.Controller">
	</context:include-filter>
</context:component-scan>

基于注解方式进行属性注入
@AutoWired:根据属性类型进行自动装配(spring)
第一步：把service和dao都加上注解
第二步:在service注入dao对象，在service类添加dao类型属性，在属性上面使用注解
@Quaifier:根据属性名称进行注入 @Quaifier(value="bean的名称")配合@Component(value="bean名称")进行使用(spring)
这个@Qualifier注解的使用，和上面的@AutoWired一起使用，根据名称和类型进行注入
@Resource:可以根据类型注入@Resource也可以根据名称注入@Resource(name="")(java)
@Value:注入基本类型属性
@Value(value="")
完全注解开发
1.创建配置类

@Configuration //作为配置类，替代xml配置文件
@Component(basePackage={""})
public class springConfig{

}

编写测试类

public void testService(){
	ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
	UserService userService = context.getBean("userService",UserService.class);
	System.out.println(userService);
}

AOP

AOP概念：Aspect Oriented Programming 面向切面编程或者面向方面编程
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
通俗描述：不通过修改源代码方式，在主干功能里面添加新功能

AOP的底层原理

1.AOP底层使用动态代理

有两种情况动态代理
第一种情况有接口情况，使用jdk动态代理，创建UserDao接口实现类代理对象增强类的方法
第二种情况动态代理没有接口情况，使用CGLIB动态代理，创建当前类子类的代理对象，增强类的方法

AOP(JDK动态代理)

使用jdk动态代理，使用Proxy类里面的方法创建代理对象

调用newProxyInstance方法
static Object newProxyInstance(ClassLoader loader,类<?>[] interfaces, InvocationHandler h)
返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序
方法有三个参数：
第一参数：类加载器
第二参数，增强方法所在类，这个类实现的接口，支持多个接口
第三个参数，实现这个接口InvocationHandler，创建代理对象，写增强的部分
编写jdk动态代理方法编写
1. 创建接口，定义方法
2. 创建接口实现类，实现方法
3. 使用Proxy类创建接口代理对象

public class JDKProxy {
	public static void main(String[] args) {
		//创建接口实现类代理对象
		Class[] interfaces = {UserDao.class};
		UserDaoImpl userDao = new UserDaoImpl();
		Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new UserDaoProxy(userDao));
	}
}
//创建代理对象代码
class UserDaoProxy implements InvocationHandler{

	//1.把创建的是谁的代理对象，把谁传递过来
	//有参数构造传递
	private  Object obj;
	public UserDaoProxy(Object obj){
		this.obj = obj;
	}
	//增强的逻辑
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// 方法之前
		System.out.println("方法之前执行..."+method.getName()+"：传递的参数..."+ Arrays.toString(args));
		// 被增强方法执行
		Object res = method.invoke(obj, args);
		// 方法之后
		System.out.println("方法之后执行..."+obj);
		return res;
	}
}

AOP术语
1. 连接点：类里面哪些方法可以被增强，这些方法称为连接点
2. 切入点：实际被真正增强的方法叫做切入点，比如四个方法可以增强，只增强了一个方法，这个被增强的方法就叫做切入点
3. 通知（增强）：（1）实际增强的部分称为通知（增强）（2）通知有多种类型：前置通知，后置通知，环绕通知，异常通知，最终通知
4. 切面：是动作（1）把通知应用到切入点的过程
AOP操作（准备）
1. Spring框架一般都是基于AspectJ实现AOP操作
  什么是AspectJ:AspectJ不是Spring组成部分，独立AOP框架，一般把ASpectJ和Spring框架一起使用，进行AOP操作
2. 基于AspectJ实现AOP操作
  （1）基于xml配置文件实现
  （2）基于注解方式实现（使用）
3. 在项目工程里面引入AOP依赖
4. 切入点表达式
  （1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强
  （2）语法结构：
  execution([权限修饰符][返回类型][类全路径][方法名称][参数列表])
  举例一：对com.ls.dao.bookDao类里面的add方法进行增强
  execution(* com.ls.dao.booDao.add(..))
  举例二：对com.ls.dao.bookDao类里面的所有方法进行增强
  execution(* com.ls.dao.booDao.(..))
  举例三：对com.ls.dao包里面的所有方法，所有类进行增强
  execution( com.ls.dao..(..))

AOP操作（AspectJ注解）

1、创建类，在类里面定义方法

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

2、创建增强类（编写增强逻辑）
(1)在增强类里面，创建方法，让不同方法代表不同通知类型

//增强的类
public class UserProxy{
	//前置通知
	public void before(){
		System.out.println("before...")
	}
}

3、进行通知的配置
(1)在spring配置文件中，开启注解扫描

 <!-- 开启注解扫描-->
    <context:component-scan base-package="com.ls.aopanno"></context:component-scan>

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

(2)使用注解创建User和UserProxy对象

//被增强类
@Component
public class User {
    public void add(){
        System.out.println("add...");
    }
}
//增强类
@Component
@Aspect //生成代理对象
public class UserProxy {

    //前置通知
    //@Before注解表示作为前置通知
    @Before("execution(* com.ls.aopanno.User.add(..))")
    public void before(){
        System.out.println("before...");
    }
    //后置通知
    //@After注解表示作为后置通知
    @After("execution(* com.ls.aopanno.User.add(..))")
    public void after(){
        System.out.println("after...");
    }
    //后置通知（返回通知）
    //@AfterReturning注解表示作为返回值后执行
    @AfterReturning("execution(* com.ls.aopanno.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning...");
    }
    //异常通知
    //@AfterThrowing注解表示作为前置通知
    @AfterThrowing("execution(* com.ls.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing...");
    }
    //环绕通知,在之前和之后都执行一次
    //@Around注解表示作为环绕通知
    @Around("execution(* com.ls.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceeding) throws Throwable{
        System.out.println("环绕之前...");
        //被增强的方法执行
        proceeding.proceed();

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

(3)在增强类上面添加注解@Aspect
(4)在sping配置文件中开启生成代理对象
(5)配置不同类型的通知
在增强类里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置
4、相同切入点进行配置，对切入点进行抽取

//相同切入点抽取
    @Pointcut(value = "execution(* com.ls.aopanno.User.add(..))")
    public void pointdemo(){

    }

    //前置通知
    //@Before注解表示作为前置通知
    @Before(value="pointdemo()")
    public void before(){
        System.out.println("before...");
    }

5、有多个增强类多同一个方法进行增强，设置增强的优先级
在增强类上面添加注解@Order(数字类型值),值越小优先级越高

@Component
@Aspect
@Order(1)

6、AOP操作(AspectJ配置文件)
1. 创建两个类，增强类和被增强类，创建方法

2. 在spring配置文件中创建两个类对象
```xml
<!--创建两个类的对象-->
<bean id="book" class="com.ls.aopxml.Book"></bean>
<bean id="bookProxy" class="com.ls.aopxml.BookProxy"></bean>
```
3. 在spring配置文件中配置切入点
```xml
<!--配置aop增强-->
<aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* com.ls.aopxml.Book.buy(..))"/>
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!-- 增强作用在具体的方法上-->
            <aop:before method="before" pointcut-ref="p"></aop:before>
        </aop:aspect>
</aop:config>
```

7、纯注解开发
添加配置文件

@Configuration
@ComponentScan(basePackages = {"com.ls"})
@EnableAspectJAutoProxy(proxyTargetClass = true)//开启Aspect生成代理对象
public class ConfigAop {
}

JdbcTemplate

什么是jdbcTemplate

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

引入jdbcTemplate

在applicationContext中引入

<!-- 在数据库中配置数据库连接池-->
<context:property-placeholder location="classpath:*.properties"/>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <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">
        <!--注入dataSource-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

创建service类，创建dao类，在dao注入jdbcTemplate对象(准备工作)

1.配置组件扫描
<context:component-scan base-package="com.ls"/>
2.service对象

@Service
public class BookService {
    //注入dao
    @Autowired
    private BookDao bookDao;
}

3.dao对象

public interface BookDao {
}
@Repository
public class BookDaoImpl implements BookDao{
    @Autowired
    private JdbcTemplate jdbcTemplate;

}

jdbc操作数据库（添加）（修改和删除操作一样）

（1）在dao进行数据库添加操作
（2）调用JdbcTemplate对象里面update方法实现添加操作
update(String sql,Object... args)
有两个参数
第一个参数：sql语句
第二个参数：可变参数

@Repository
public class BookDaoImpl implements BookDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void add(User book) {
    //1.创建sql语句
    String sql = "insert into t_user values(?,?,?)";
        int update = jdbcTemplate.update(sql, book.getUserId(), book.getUsername(), book.getUstatus());
        System.out.println(update);
    }

    @Override
    public void updateUser(User user) {
        //1.创建sql语句
        String sql = "update t_user set username= ? where user_id= ? ";
        //执行sql
        int update = jdbcTemplate.update(sql,user.getUsername(),user.getUserId());
        System.out.println(update);
    }

    @Override
    public void deleteUser(String id) {
        //1.创建sql语句
        String sql = "delete from t_user where user_id=?";
        //执行sql
        int update = jdbcTemplate.update(sql,id);
        System.out.println(update);
    }
}

jdbc操作数据库（查询返回某个值）

查询表里面有多少条记录，返回的是某个值
select count(*) from 表名;
使用jdbcTemplate进行查询
queryForObject(String sql,Class requiredType);
需要两个参数：
第一个参数代表sql语句
第二个参数代表返回值的类型

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

jdbc操作数据库（查询返回对象）

T queryForObject(String var1, RowMapper var2, @Nullable Object... var3) throws DataAccessException;
第一个参数sql
第二个RowMapper，是接口，返回不同类型数据，使用这个接口里面完成数据封装
第三个sql语句值

String sql = "select * from t_book where user_id=?";
  //调用方法
  User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class), id);
  return user;
 }

jdbc操作数据库（查询返回集合）

T query(String var1, ResultSetExtractor var2, @Nullable Object... var3) throws DataAccessException;
第一个参数sql
第二个RowMapper，是接口，返回不同类型数据，使用这个接口里面完成数据封装
第三个sql语句值

@Override
    public List<User> findAll() {
        String sql = "select * from t_book";
        List<User> users = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
        return users;
    }

jdbc操作数据库（批量操作）

批量操作：操作表里面多条记录
2.jdbcTemplate:实现批量添加操作

String sql ="insert into t_book values(?,?,?)";
  //在执行过程中对 batchArgs进行遍历
  List<Object[]> batch = new ArrayList<>();
  Object[] o1 = {"3","book","a"};
  Object[] o2 = {"4","book","a"};
  Object[] o3 = {"5","book","a"};
  batch.add(o1);
  batch.add(o2);
  batch.add(o3);
  int[]  ints = jdbcTemplate.batchUpdate(sql,batch);
  System.out.println(Arrays.toString(ints));

事务管理

1、什么是事务：事务时数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败，所有操作都失败
2、典型场景，银行转账
3、事务的四大特性（ACID）：
(1). 原子性（Atomicity）：例如，在多线程编程中，如果一个线程执行一个原子操作，这意味着另一个线程无法看到该操作的一半结果。系统只能处于操作之前或操作之后的状态，而不是介于两者之间的状态。 ACID原子性的定义特征是：能够在错误时中止事务，丢弃该事务进行的所有写入变更的能力。
(2). 一致性（Consistency）：ACID一致性的概念是，对数据的一组特定陈述必须始终成立。即不变量（invariants）。例如，在会计系统中，所有账户整体上必须借贷相抵。如果一个事务开始于一个满足这些不变量的有效数据库，且在事务处理期间的任何写入操作都保持这种有效性，那么可以确定，不变量总是满足的。原子性，隔离性和持久性是数据库的属性，而一致性（在ACID意义上）是应用程序的属性。应用可能依赖数据库的原子性和隔离属性来实现一致性，但这并不仅取决于数据库。
(3). 隔离性（Isolation）：ACID意义上的隔离性意味着，同时执行的事务是相互隔离的：它们不能相互冒犯。如果两个事务不触及相同的数据，它们可以安全地并行（parallel）运行，因为两者都不依赖于另一个。当一个事务读取由另一个事务同时修改的数据时，或者当两个事务试图同时修改相同的数据时，并发问题（竞争条件）才会出现。出于这个原因，数据库一直试图通过提供事务隔离（transaction isolation）来隐藏应用程序开发者的并发问题。
(4). 持久性（Durability）：数据库系统的目的是，提供一个安全的地方存储数据，而不用担心丢失。持久性是一个承诺，即一旦事务成功完成，即使发生硬件故障或数据库崩溃，写入的任何数据也不会丢失。

事务操作（搭建事务操作环境）

在dao中创建两个方法：一个少钱的方法，一个多钱的方法
在service中创建一个转账的方法：调用dao中的方法

1、创建数据库创建表

2、创建service，搭建dao，完成对象注入

3、使用事务来解决银行转账问题基本过程
（1）. 第一步开启事务
（2）. 进行业务操作
（3）. 如果没有发生异常，提交事务
（4）. 如果出现异常，事务回滚

事务操作（Spring事务管理）
（1）事务添加到Service层（业务逻辑操作）
（2）在Spring进行事务管理操作:有两种方式：编程式事务管理（在代码中进行控制）和声明式事务管理（通过配置实现使用）

声明式事务管理

Spring事务管理API
1. 提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类
基于注解方式（常用），底层使用AOP原理。
1. 在spring配置文件中配置事务管理器
2. 在spring配置文件，在spring中引入名称空间tx,开启事务注解，
3. 在service类上边（或者service类里方法上面）添加事务注解，@Transactional//可以加到类上也可以加到方法上边，如果把这个注解添加到类上，这个类里面所有的方法都添加事务，如果把这个注解添加到方法上边，只会为此方法添加事务

<?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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/util
        https://www.springframework.org/schema/util/spring-util.xsd">
    <!-- 组件扫描 -->
    <context:component-scan base-package="com.ls"></context:component-scan>

    <!-- 数据库连接池对象 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="url" value="jdbc:mysql:///user_db"></property>
        <property name="username" value="root"></property>
        <property name="password" value="ls200222"></property>
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
    </bean>
    <!-- JDBCTemplate对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 注入dataSource-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

<!--    创建事务管理器-->
    <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>
</beans>

声明式事务管理参数配置：
propagation:事务传播行为，当一个事务方法被另一个事务方法调用时候，这个事务方法如何进行。
事务的传播行为可以由传播属性指定。spring定义了7种类传播行为：
REQUIRED:如果事务在运行，当前的方法就在这个事务内运行，否则就启动一个事务，并在自己的事务内运行。

REQUIRED_NEW:当前的方法必须启动新事务，并在它自己的事务内运行，如果有事务正在运行，应该将它挂起

方法B不依赖于方法A
SUPPOERA:如果有事务在运行，当前的方法就在这个事务内运行，否则它可以不运行在事务中

事务的隔离级别：
事务的其中一个特性，隔离性，多个事务之间不会产生影响，不考虑隔离性产生很多问题
有三个读问题：脏读，不可重复读，虚（幻）读
脏读：一个未提交事务读取到另一个未提交事务的数据。
不可重复读：两个事务拿到现同的数据，但一个未提交的事务读取到另一个已提交事务修改数据
虚读：一个未提交事务读取到另一个提交事务添加数据

解决：通过设置事务隔离界别，解决读问题

默认未REPEATABLE(可重复读 )

timeout:超时时间
事务需要在一定时间内进行提交，如果不提交进行回滚
默认值-1，不回滚，以秒为单位

readOnly:是否只读
默认值为false，设置为true只能进行查询

rollbackFor:回滚
rollbackFor =Exception.class
设置出现那些异常进行事务回滚
noRollbackFor:不回滚
设置出现那些异常不进行回滚

基于xml配置文件方式
在spring配置文件中进行配置：
第一步配置事务管理器
第二步配置通知
第三步配置切入点和切面

 <!--2.配置通知 -->
    <tx:advice id="txadvice">
<!--        配置事务参数-->
        <tx:attributes>
<!--            指定那种规则的方法上面添加事务-->
            <tx:method name="accountMoney" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
<!--    3.配置切入点和切面-->
    <aop:config>
<!--        配置切入点-->
        <aop:pointcut id="pt" expression="execution(* com.ls.service.UserService.*(..))"/>
<!--        配置切面-->
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"></aop:advisor>
    </aop:config>

事务操作（完全注解开发）

创建配置类

Spring5新特性

posted @ 2023-01-04 15:00 生活的样子就该是那样阅读(43) 评论(0) 编辑收藏举报

刷新页面返回顶部

把学习当作习惯