文章目录
- 1、Spring框架概述
- 2、IOC容器
- 3、AOP
- 4、JdbcTemplate
- 5、事务管理
本文笔记所学内容来自 尚硅谷的Spring5框架课程
1、Spring框架概述
- Spring 是轻量级的开源的 JavaEE 框架
- Spring 可以解决企业应用开发的复杂性
- Spring 有两个核心部分:IOC 和 Aop
- IOC:控制反转,把创建对象过程交给 Spring 进行管理
- Aop:面向切面,不修改源代码进行功能增强
- Spring 特点
- 方便解耦,简化开发
- Aop 编程支持
- 方便程序测试
- 方便和其他框架进行整合
- 方便进行事务操作
- 降低 API 开发难度
- 现在课程中,选取 Spring 版本 5.x
2、IOC容器
2.1、什么是 IOC
- 控制反转,把对象创建和对象之间的调用过程,交给 Spring 进行管理
- 使用 IOC 目的:为了耦合度降低
- 做入门案例就是 IOC 实现
2.2、Spring5入门案例:
-
下载Spring5,下载地址
-
打开 idea 工具,创建普通 Java 工程
-
导入 Spring5 相关 jar 包,并添加到工程里
-
创建普通类,在这个类创建普通方法
package com.weeks.spring5.bean;
public class User {
public void add(){
System.out.println("add...");
}
}
- 创建 Spring 配置文件,在配置文件配置创建的对象
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="user" class="com.weeks.spring5.bean.User"/>
</beans>
- 进行测试代码编写
public class SpringTest {
@Test
public void testAdd(){
ApplicationContext context =
new ClassPathXmlApplicationContext("userbean.xml");
User user = context.getBean("user", User.class);
System.out.println(user);
user.add();
}
}
2.3、IOC底层原理
-
IOC底层原理
- xml解析
- 工厂模式
- 反射
-
画图讲解IOC底层原理
2.2、IOC接口(BeanFactory)
- IOC思想基于IOC容器完成,IOC容器底层就是对象工厂
- Spring提供IOC容器实现两种方式:(两个接口)
- BeanFactory:IOC容器基本实现,是Spring内部的使用接口,不提供开发人员进行使用,加载配置文件时不会创建对象,在获取对象(使用)才会创建对象。
- ApplicationContext: BeanFactory接口的子接口,提供了更加强大的功能,一般由开发人员进行使用,加载配置文件时就会在配置文件对象进行创建。
- ApplicationContext接口的实现类
2.3、IOC操作Bean管理(基于XML)
什么是Bean管理
- Bean管理指的是两个操作:
- Spring创建对象
- Spring注入属性
- Bean管理操作有两种方式:
- 基于xml配置文件方式实现
- 基于注解方式实现
基于xml方式创建对象
<!-- 配置User对象创建 -->
<bean id="user" class="com.weeks.spring5.bean.User"></bean>
- 在Spring配置文件中,使用bean标签,标签里面添加对应属性,就可以实现对象创建
- 在bean标签有很多属性,介绍常用的属性
- id属性:唯一标识(相当于new的对象名)
- class属性:类全路径(包类路径)
- </font color=“red”>创建对象时,默认也是执行无参构造方法完成对象创建
基于xml方式注入属性
DI:依赖注入,就是注入属性
第一种注入方式:使用set方法进行注入
- 创建类,定义属性和对应的set方法
package com.weeks.spring5.bean;
/**
* 演示使用set方法注入属性
*/
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;
}
@Override
public String toString() {
return "Book{" +
"bname='" + bname + '\'' +
", bauthor='" + bauthor + '\'' +
'}';
}
}
- 在 spring 配置文件配置对象创建,配置属性注入
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="book" class="com.weeks.spring5.bean.Book">
<!-- 使用类中的setXxx方法注入类的属性值 -->
<!--使用 property 完成属性注入
name:类里面属性名称
value:向属性注入的值
-->
<property name="bname" value="水浒传"/>
<property name="bauthor" value="施耐庵"/>
</bean>
</beans>
第二种注入方式:使用有参数构造进行注入
- 创建类,定义属性,创建属性对应有参数构造方法
package com.weeks.spring5.bean;
/**
* @author 达少
* @version 1.0
*/
@SuppressWarnings({"all"})
public class Orders {
private String oname;
private String oaddress;
//为了演示使用有参构造给类属性注入值,这里故意不定义无参构造
public Orders(String oname, String oaddress){
this.oname = oname;
this.oaddress = oaddress;
}
@Override
public String toString() {
return "Orders{" +
"oname='" + oname + '\'' +
", oaddress='" + oaddress + '\'' +
'}';
}
}
- 在 spring 配置文件中进行配置
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="orders" class="com.weeks.spring5.bean.Orders">
<!-- 使用有参构造给类对象输入属性值 -->
<constructor-arg name="oname" value="order01"/>
<constructor-arg name="oaddress" value="广州"/>
</bean>
</beans>
p 名称空间注入(了解)
-
使用 p 名称空间注入,可以简化基于 xml 配置方式
-
第一步 添加 p 名称空间在配置文件中
<bean id="book" class="com.weeks.spring5.bean.Book" p:bname="平凡的世界" p:bauthor="路遥"></bean>
IOC 操作 Bean 管理(xml 注入其他类型属性)
字面值
- null值
<!-- null值 -->
<property name="address">
<null/>
</property>
注入属性-外部 bean
- 创建两个类 service 类和 dao 类
- 在 service 调用 dao 里面的方法
- 在 spring 配置文件中进行配置
package com.weeks.spring5.dao;
/**
* dao类
*/
public interface UserDao {
public void update();
}
package com.weeks.spring5.service;
import com.weeks.spring5.dao.UserDao;
/**
* service类
*/
public class UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void add(){
System.out.println("userService add ...");
userDao.update();
}
}
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- service 和 dao 对象创建-->
<bean id="userService" class="com.weeks.spring5.service.UserService">
<!--注入 userDao 对象
name 属性:类里面属性名称
ref 属性:创建 userDao 对象 bean 标签 id 值
-->
<property name="userDao" ref="userDaoImpl"/>
</bean>
<bean id="userDaoImpl" class="com.weeks.spring5.dao.UserDaoImpl"></bean>
</beans>
注入属性-内部 bean
- 一对多关系:部门和员工, 一个部门有多个员工,一个员工属于一个部门
- 部门是一,员工是多, 在实体类之间表示一对多关系,员工表示所属部门,使用对象类型属性进行表示
- 在 spring 配置文件中进行配置
package com.weeks.spring5.bean;
/**
* 部门类
*/
public class Dept {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "Dept{" +
"name='" + name + '\'' +
'}';
}
}
package com.weeks.spring5.bean;
/**
* 员工类
*/
public class Emp {
private String name;
private String gender;
//级联属性
private Dept dept;
public void setName(String name) {
this.name = name;
}
public void setGender(String gender) {
this.gender = gender;
}
public void setDept(Dept dept) {
this.dept = dept;
}
public Dept getDept() {
return dept;
}
public void showInfo(){
System.out.println(name + "::" + 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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="emp" class="com.weeks.spring5.bean.Emp">
<property name="name" value="李逵"/>
<property name="gender" value="男"/>
<property name="dept">
<!--设置对象类型属性-->
<bean id="dept" class="com.weeks.spring5.bean.Dept">
<property name="name" value="安保部"/>
</bean>
</property>
</bean>
</beans>
注入属性-级联赋值
- 第一种写法
<!-- 第一种写法 -->
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--级联赋值-->
<bean id="emp" class="com.weeks.spring5.bean.Emp">
<!--设置两个普通属性-->
<property name="name" value="李逵"/>
<property name="gender" value="男"/>
<!--级联赋值-->
<property name="dept" ref="dept"/>
<property name="dept.name" value="工商部"/>
</bean>
<bean id="dept" class="com.weeks.spring5.bean.Dept">
<property name="name" value="安保部"/>
</bean>
</beans>
- 第二种写法
<!--级联赋值--> <bean id="emp" class="com.atguigu.spring5.bean.Emp">
<!--设置两个普通属性-->
<property name="ename" value="lucy"></property>
<property name="gender" value="女"></property>
<!--级联赋值-->
<property name="dept" ref="dept"></property>
<property name="dept.dname" value="技术部"></property>
</bean> <bean id="dept" class="com.atguigu.spring5.bean.Dept">
<property name="dname" value="财务部"></property>
</bean>
xml 注入集合属性
注入数组类型属性
注入 List 集合类型属性
注入 Map 集合类型属性
步骤:
- 创建类,定义数组、list、map、set 类型属性,生成对应 set 方法
package com.weeks.spring5.bean;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.zip.CheckedOutputStream;
/**
* @author 达少
* @version 1.0
*/
public class Student {
private String[] courses;//所要学习的课程
private List<String> names;//大名和别名
private Map<String, String> coursesAlias;//课程别名
private Set<String> friends;//同伴
private List<Course> courseList;//以对象的方式传入课程
public void setCourseList(List<Course> courseList) {
this.courseList = courseList;
}
public void setCourses(String[] courses) {
this.courses = courses;
}
public List<Course> getCourseList() {
return courseList;
}
public void setNames(List<String> names) {
this.names = names;
}
public void setCoursesAlias(Map<String, String> coursesAlias) {
this.coursesAlias = coursesAlias;
}
public void setFriends(Set<String> friends) {
this.friends = friends;
}
public void show(){
System.out.println(Arrays.toString(courses));
System.out.println(names);
System.out.println(coursesAlias);
System.out.println(friends);
System.out.println(courseList);
}
}
- 在 spring 配置文件进行配置
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="student" class="com.weeks.spring5.bean.Student">
<property name="courses">
<array>
<value>扎马步</value>
<value>刺杀</value>
<value>骑马</value>
</array>
</property>
<property name="names">
<list>
<value>李逵</value>
<value>黑旋风</value>
</list>
</property>
<property name="coursesAlias">
<map>
<entry key="扎马步" value="Zhamabu"/>
<entry key="刺杀" value="cisha"/>
<entry key="骑马" value="driver"/>
</map>
</property>
<property name="friends">
<set>
<value>宋江</value>
<value>鲁智深</value>
<value>武松</value>
</set>
</property>
<!-- 以对象的方式注入属性 -->
<property name="courseList">
<list>
<ref bean="course1"/>
<ref bean="course2"/>
<ref bean="course3"/>
</list>
</property>
</bean>
<bean id="course1" class="com.weeks.spring5.bean.Course">
<property name="name" value="扎马步"/>
</bean>
<bean id="course2" class="com.weeks.spring5.bean.Course">
<property name="name" value="刺杀"/>
</bean>
<bean id="course3" class="com.weeks.spring5.bean.Course">
<property name="name" value="骑马"/>
</bean>
</beans>
在集合里面设置对象类型值
<!--创建多个 course 对象--> <bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
<property name="cname" value="Spring5 框架"></property>
</bean> <bean id="course2" class="com.atguigu.spring5.collectiontype.Course">
<property name="cname" value="MyBatis 框架"></property>
</bean>
<!--注入 list 集合类型,值是对象--> <property name="courseList">
<list>
<ref bean="course1"></ref>
<ref bean="course2"></ref>
</list>
</property>
把集合注入部分提取出来
- 在 spring 配置文件中引入名称空间 util
- 使用 util 标签完成 list 集合注入提取
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util
https://www.springframework.org/schema/util/spring-util.xsd">
<!--
被<![CDATA[]]>这个标记所包含的内容将表示为纯文本,比如<![CDATA[<]]>表示文本内容“<”。
-->
<!-- 提取属性值作为工共部分,方便复用 -->
<util:list id="bookNames">
<value><![CDATA[<<红楼梦>>]]></value>
<value><![CDATA[<<西游记>>]]></value>
<value><![CDATA[<<三国演义>>]]></value>
<value><![CDATA[<<水浒传>>]]></value>
</util:list>
<util:map id="bookAuthors">
<entry key="曹雪芹">
<value><![CDATA[<<红楼梦>>]]></value>
</entry>
<entry key="吴承恩">
<value><![CDATA[<<西游记>>]]></value>
</entry>
<entry key="罗贯中">
<value><![CDATA[<<三国演义>>]]></value>
</entry>
<entry key="施耐庵">
<value><![CDATA[<<水浒传>>]]></value>
</entry>
</util:map>
<bean id="books" class="com.weeks.spring5.bean.Book" scope="prototype">
<property name="names" ref="bookNames"/>
<property name="authors" ref="bookAuthors"/>
</bean>
</beans>
IOC 操作 Bean 管理(FactoryBean)
- Spring 有两种类型 bean,一种普通 bean,另外一种工厂 bean(FactoryBean)
- 普通 bean:在配置文件中定义 bean 类型就是返回类型
- 工厂 bean:在配置文件定义 bean 类型可以和返回类型不一样
- 创建类,让这个类作为工厂 bean,实现接口 FactoryBean
- 实现接口里面的方法,在实现的方法中定义返回的 bean 类型
package com.weeks.spring5.bean;
import org.springframework.beans.factory.FactoryBean;
/**
* @author 达少
* @version 1.0
*/
public class MyBean implements FactoryBean<Course> {
@Override
public Course getObject() throws Exception {
Class<?> aClass = Class.forName("com.weeks.spring5.bean.Course");
Course course = (Course) aClass.newInstance();
course.setName("abc");
return course;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return false;
}
}
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="myBean" class="com.weeks.spring5.bean.MyBean">
</bean>
</beans>
//测试工厂bean
@Test
public void testFactoryBean(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean3.xml");
Course course = context.getBean("myBean", Course.class);
System.out.println(course);
}
IOC 操作 Bean 管理(bean 作用域)
- 在 Spring 里面,设置创建 bean 实例是单实例还是多实例
- 在 Spring 里面,默认情况下,bean 是单实例对象
//测试bean的作用域scope属性,常用的有两种值
/**
* singleton:默认值,表示创建单实例对象
* prototype:表示创建多实例对象
*/
@Test
public void testScope(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean2.xml");
Book books01 = context.getBean("books", Book.class);
Book books02 = context.getBean("books", Book.class);
System.out.println(books01.hashCode() + "," + books02.hashCode());
}
- 如何设置单实例还是多实例
- 在 spring 配置文件 bean 标签里面有属性(scope)用于设置单实例还是多实例
- scope 属性值
- 默认值,singleton,表示是单实例对象
- prototype,表示是多实例对象
- singleton 和 prototype 区别
- singleton 单实例,prototype 多实例
- 设置 scope 值是 singleton 时候,加载 spring 配置文件时候就会创建单实例对象;设置 scope 值是 prototype 时候,不是在加载 spring 配置文件时候创建 对象,在调用getBean 方法时候创建多实例对象。
<bean id="books" class="com.weeks.spring5.bean.Book" scope="prototype">
<property name="names" ref="bookNames"/>
<property name="authors" ref="bookAuthors"/>
</bean>
IOC 操作 Bean 管理(bean 生命周期)
生命周期:从对象创建到对象销毁的过程
bean 生命周期
- 通过构造器创建 bean 实例(无参数构造)
- 为 bean 的属性设置值和对其他 bean 引用(调用 set 方法)
- 调用 bean 的初始化的方法(需要进行配置初始化的方法)
- bean 可以使用了(对象获取到了)
- 当容器关闭时候,调用 bean 的销毁的方法(需要进行配置销毁的方法)
package com.weeks.spring5.bean;
/**
* 演示bean的生命周期
*/
public class Orders {
private String name;
public Orders(){
System.out.println("第一步 调用构造方法参见实例对象");
}
public void setName(String name) {
System.out.println("第二步 调用set方法设置类属性值");
this.name = name;
}
public void initMethod(){
System.out.println("第三步 调用初始化方法(需要在xml文件中配置才能调用)");
}
public void destroyMethod(){
System.out.println("第五步 调用销毁方法(需要在xml文件中配置才能调用)");
}
}
//测试bean的生命周期
@Test
public void testScope02(){
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("bean4.xml");
Orders orders = context.getBean("orders", Orders.class);
System.out.println(orders);
System.out.println("第四步 使用创建的bean实例对象");
//销毁bean
context.close();
}
<!-- bean4.xml -->
<bean id="orders" class="com.weeks.spring5.bean.Orders"
init-method="initMethod" destroy-method="destroyMethod">
<property name="name" value="phone"/>
</bean>
bean 的后置处理器,bean 生命周期有七步
- 通过构造器创建 bean 实例(无参数构造)
- 为 bean 的属性设置值和对其他 bean 引用(调用 set 方法)
- 把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization
- 调用 bean 的初始化的方法(需要进行配置初始化的方法)
- 把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization
- bean 可以使用了(对象获取到了)
- 当容器关闭时候,调用 bean 的销毁的方法(需要进行配置销毁的方法)
package com.weeks.spring5.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.lang.Nullable;
/**
* @author 达少
* @version 1.0
*/
public class MyPost 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;
}
}
<!-- bean4.xml -->
<!-- 创建后处理器的bean,该文件中的所有bean都会调用这个后处理器 -->
<bean id="mypost" class="com.weeks.spring5.bean.MyPost"></bean>
//增加后处理器后,测试bean的声明周期
@Test
public void testScope03(){
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("bean4.xml");
Orders orders = context.getBean("orders", Orders.class);
System.out.println(orders);
System.out.println("第四步 使用创建的bean实例对象");
//销毁bean
context.close();
}
IOC 操作 Bean 管理(xml 自动装配)
什么是自动装配
- 根据指定装配规则(属性名称或者属性类型),Spring 自动将匹配的属性值进行注入
演示自动装配过程
- 根据属性名称自动注入
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
属性自动装配:autowire标签
byName:通过属性名来自动装配,装配的属性名要和对应的对象名一致
byType:通过属性类型来自动装配,但是在beans中只能定义一个该类的bean对象,否则byType识别不出
应该装配哪一个
-->
<bean id="emp" class="com.weeks.spring5.autowire.Emp" autowire="byName"></bean>
<bean id="dept" class="com.weeks.spring5.autowire.Dept"></bean>
</beans>
package com.weeks.spring5.autowire;
public class Dept {
@Override
public String toString() {
return "dept{}";
}
}
package com.weeks.spring5.autowire;
public class Emp {
private Dept dept;
@Override
public String toString() {
return "Emp{" +
"dept=" + dept +
'}';
}
public void show(){
System.out.println(dept);
}
}
- 根据属性类型自动注入
<!--
属性自动装配:autowire标签
byName:通过属性名来自动装配,装配的属性名要和对应的对象名一致
byType:通过属性类型来自动装配,但是在beans中只能定义一个该类的bean对象,否则byType识别不出
应该装配哪一个
-->
<bean id="emp" class="com.weeks.spring5.autowire.Emp" autowire="byType"></bean>
<bean id="dept" class="com.weeks.spring5.autowire.Dept"></bean>
IOC 操作 Bean 管理(外部属性文件)
直接配置数据库信息
- 配置德鲁伊连接池
- 引入德鲁伊连接池依赖 jar 包
<!-- 传统配置 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/weeks_db03"/>
<property name="username" value="root"/>
<property name="password" value="xxxx"/>
</bean>
引入外部属性文件配置数据库连接池
- 创建外部属性文件,properties 格式文件,写数据库信息
- 把外部 properties 属性文件引入到 spring 配置文件中
- 引入 context 名称空间
- 在 spring 配置文件使用标签引入外部属性文件
<!--引入外部属性文件-->
<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>
2.4、IOC操作Bean管理(基于注解)
什么是注解
- 注解是代码特殊标记,格式:@注解名称(属性名称=属性值, 属性名称=属性值…)
- 使用注解,注解作用在类上面,方法上面,属性上面
- 使用注解目的:简化 xml 配置
Spring 针对 Bean 管理中创建对象提供注解
- @Component
- @Service
- @Controller
- @Repository
- 上面四个注解功能是一样的,都可以用来创建 bean 实例
基于注解方式实现对象创建
-
第一步 引入依赖,并添加到工程中
-
第二步 开启组件扫描
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--开启组件扫描
1 如果扫描多个包,多个包使用逗号隔开
2 扫描包上层目录
-->
<context:component-scan base-package="com.weeks.spring5"></context:component-scan>
</beans>
- 第二步 开启组件扫描
package com.weeks.spring5.service;
import com.weeks.spring5.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
//在注解里面 value 属性值可以省略不写,
//默认值是类名称,首字母小写
//UserService -- userService
@Component(value = "userService")
public class UserService {
public void add(){
System.out.println("add...");
}
}
开启组件扫描细节配置
<!--示例 1
use-default-filters="false" 表示现在不使用默认 filter,自己配置 filter
context:include-filter ,设置扫描哪些内容
-->
<context:component-scan base-package="com.weeks.spring5.service" use-default-filters="false">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!--示例 2
下面配置扫描包所有内容
context:exclude-filter: 设置哪些内容不进行扫描
-->
<context:component-scan base-package="com.weeks.spring5.service">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
基于注解方式实现属性注入
- @Autowired:根据属性类型进行自动装配
- 第一步 把 service 和 dao 对象创建,在 service 和 dao 类添加创建对象注解
- 第二步 在 service 注入 dao 对象,在 service 类添加 dao 类型属性,在属性上面使用注解
package com.weeks.spring5.dao;
public interface UserDao {
public void add();
}
package com.weeks.spring5.dao;
import org.springframework.stereotype.Component;
@Component(value = "userDaoImpl")
public class UserDaoImpl implements UserDao{
@Override
public void add() {
System.out.println("UserDao add...");
}
}
package com.weeks.spring5.service;
import com.weeks.spring5.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Component(value = "userService")
public class UserService {
//通过注解注入属性值不需要定义setXxx方法
//注入对象属性使用@Autowired,@Qualifier,@Resource
// @Autowired//通过类型注入属性
// @Qualifier(value = "userDaoImpl")//通过属性名注入属性,要和@Autowired一起使用
// @Resource//通过类型注入属性
@Resource(name = "userDaoImpl")//通过名称注入属性
private UserDao userDao;
//注入普通属性使用@Value注解
@Value("jack")
private String name;
public void add(){
System.out.println("add...");
System.out.println(name);
userDao.add();
}
}
完全注解开发
- 创建配置类,替代 xml 配置文件
package com.weeks.spring5.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
//创建配置类替代xml文件,实现完全注解开发
@Configuration//配置注解
@ComponentScan(basePackages = {"com.weeks.spring5"})
public class SpringConfig {
}
- 编写测试类
package com.weeks.spring5.test;
import com.weeks.spring5.config.SpringConfig;
import com.weeks.spring5.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTest {
//测试完全注解开发
@Test
public void testAllAnnotationDev(){
//加载配置类
ApplicationContext context =
new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
}
3、AOP
3.1、AOP(概念)
什么是 AOP
- 面向切面编程(方面),利用 AOP 可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
- 通俗描述:不通过修改源代码方式,在主干功能里面添加新功能
- 使用登录例子说明 AOP
3.2、AOP(底层原理)
AOP 底层使用动态代理
有两种情况动态代理
-
第一种 有接口情况,使用 JDK 动态代理
- 创建接口实现类代理对象,增强类的方法
- 创建接口实现类代理对象,增强类的方法
-
第二种 没有接口情况,使用 CGLIB 动态代理
- 创建子类的代理对象,增强类的方法
- 创建子类的代理对象,增强类的方法
3.3、AOP(JDK 动态代理)
使用 JDK 动态代理,使用 Proxy 类里面的方法创建代理对象
- 调用 newProxyInstance 方法
- 方法有三个参数:
- 第一参数,类加载器
- 第二参数,增强方法所在的类,这个类实现的接口,支持多个接口
- 第三参数,实现这个接口 InvocationHandler,创建代理对象,写增强的部分
- 方法有三个参数:
编写 JDK 动态代理代码
- 创建接口,定义方法
package com.weeks.spring5.dao;
public interface UserDao {
public int add(int a, int b);
public String update(String name);
}
- 创建接口实现类,实现方法
package com.weeks.spring5.dao;
public class UserDaoImpl implements UserDao{
@Override
public int add(int a, int b) {
System.out.println("add..");
return a + b;
}
@Override
public String update(String name) {
System.out.println("update...");
return name;
}
}
- 使用 Proxy 类创建接口代理对象
package com.weeks.spring5.test;
import com.weeks.spring5.dao.UserDao;
import com.weeks.spring5.dao.UserDaoImpl;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
public class TestProxy {
public static void main(String[] args) {
UserDao userDao = new UserDaoImpl();
Class[] interfaces = {UserDao.class};
// Proxy.newProxyInstance(TestProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
// @Override
// public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// return null;
// }
// });
UserDao dao = (UserDao) Proxy.newProxyInstance(
TestProxy.class.getClassLoader(), interfaces,
new ObjectProxy(userDao));
int add = dao.add(1, 2);
System.out.println(add);
}
}
class ObjectProxy implements InvocationHandler{
//把要创建代理的类的对象传递过来
private Object obj;
//通过有参构造传统类对象
public ObjectProxy(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("方法执行后...");
return res;
}
}
3.4、AOP(术语)
- 连接点:类里面那些方法可以增强,这些方法称为连接点。
- 切入点:实际被真正增强的方法,称为切入点
- 通知(增强)
- 实际增强的逻辑部分称为通知(增强)
- 通知有多种类型
- 前置通知
- 后置通知
- 环绕通知
- 异常通知
- 最终通知
- 切面,把通知应用到切入点的过程这个动作称为切面
3.5、AOP 操作(准备工作)
(1)Spring 框架一般都是基于 AspectJ 实现 AOP 操作
- AspectJ 不是 Spring 组成部分,独立 AOP 框架,一般把 AspectJ 和 Spirng 框架一起使用,进行 AOP 操作。
(2)基于 AspectJ 实现 AOP 操作
- 基于 xml 配置文件实现
- 基于注解方式实现(使用)
(3)在项目工程里面引入 AOP 相关依赖
(4)切入点表达式
- 切入点表达式作用:知道对哪个类里面的哪个方法进行增强
- 语法结构: execution([权限修饰符] [返回类型] [类全路径] 方法名称 )
举例 1:对 com.atguigu.dao.BookDao 类里面的 add 进行增强
execution(* com.atguigu.dao.BookDao.add(..))
举例 2:对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强
execution(* com.atguigu.dao.BookDao.* (..))
举例 3:对 com.atguigu.dao 包里面所有类,类里面所有方法进行增强
execution(* com.atguigu.dao.*.* (..))
3.6、AOP 操作(AspectJ 注解)
(1)创建类,在类里面定义方法
public class User {
public void add(){
//int i = 10 / 0;
System.out.println("add...");
}
}
(2)创建增强类(编写增强逻辑)
public class UserProxy {
@Before(value = "demo()")
public void before(){
System.out.println("before...");
}
}
(3)进行通知的配置
- 在 spring 配置文件中,开启注解扫描
<?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
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">
<!-- 开启注解扫描 -->
<context:component-scan base-package="com.weeks.spring5.aopannotation"></context:component-scan>
<!-- 开启 Aspect 生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
- 使用注解创建 User 和 UserProxy 对象
@Component(value = "user")
public class User {
@Component(value = "userProxy")
public class UserProxy {
- 在增强类上面添加注解 @Aspect
@Component(value = "userProxy")
@Aspect
public class UserProxy {
- 在 spring 配置文件中开启生成代理对象
<!-- 开启 Aspect 生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
(4)配置不同类型的通知
- 在增强类的里面,在作为通知方法上面添加通知类型注解,使用切入点表达式配置
package com.weeks.spring5.aopannotation;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
//增强的类
@Component(value = "userProxy")
@Aspect//生成代理对象
public class UserProxy {
//相同切入点抽取
@Pointcut(value = "execution(* com.weeks.spring5.aopannotation.User.add(..))")
public void demo(){}
//前置通知
//@Before 注解表示作为前置通知
@Before(value = "execution(* com.weeks.spring5.aopannotation.User.add(..))")
public void before(){
System.out.println("before...");
}
//最终通知
@After(value = "execution(* com.weeks.spring5.aopannotation.User.add(..))")
public void after(){
System.out.println("After...");
}
//环绕通知
@Around(value = "execution(* com.weeks.spring5.aopannotation.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("around before...");
proceedingJoinPoint.proceed();//要执行的方法
System.out.println("around after...");
}
//后置通知(返回通知)
@AfterReturning(value = "execution(* com.weeks.spring5.aopannotation.User.add(..))")
public void afterReturning(){
System.out.println("after returning...");
}
//异常通知
@AfterThrowing(value = "execution(* com.weeks.spring5.aopannotation.User.add(..))")
public void afterThrowing(){
System.out.println("after throwing...");
}
}
(5)相同的切入点抽取
@Pointcut(value = "execution(* com.weeks.spring5.aopannotation.User.add(..))")
public void demo(){}
@Before(value = "demo()")
public void before(){
System.out.println("before...");
}
(6)有多个增强类多同一个方法进行增强,设置增强类优先级
- 在增强类上面添加注解 @Order(数字类型值),数字类型值越小优先级越高(从0开始)
@Component(value = "userProxy")
@Aspect
@Order(1)
public class UserProxy {
(7)完全使用注解开发
@Configuration
@ComponentScan(basePackages = {"com.weeks"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}
3.7、AOP 操作(AspectJ 配置文件)
- 创建两个类,增强类和被增强类,创建方法
package com.weeks.spring5.aopxml;
public class Book {
public void buy(){
System.out.println("buy...");
}
}
package com.weeks.spring5.aopxml;
public class BookProxy {
public void beforeBuy(){
System.out.println("before buy...");
}
}
- 在 spring 配置文件中创建两个类对象
<!-- 创建类的对象 -->
<bean id="book" class="com.weeks.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.weeks.spring5.aopxml.BookProxy"></bean>
- 在 spring 配置文件中配置切入点
<aop:config>
<!-- 配置切入点 -->
<aop:pointcut id="pointcut" expression="execution(* com.weeks.spring5.aopxml.Book.buy(..))"/>
<!-- 配置切面 -->
<aop:aspect ref="bookProxy">
<!-- 增强的方法 -->
<aop:before method="beforeBuy" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
4、JdbcTemplate
4.1、JdbcTemplate(概念和准备)
(1)什么是 JdbcTemplate
- Spring 框架对 JDBC 进行封装,使用 JdbcTemplate 方便实现对数据库操作
(2)准备工作
- 引入相关 jar 包
- 在 spring 配置文件配置数据库连接池
//database infomation
mysql.driver=com.mysql.jdbc.Driver
mysql.url=jdbc:mysql://localhost:3306/user_db?characterEncoding=UTF-8&rewriteBatchedStatements=true
mysql.username=root
mysql.password=root
<!-- 配置数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${mysql.driver}"/>
<property name="url" value="${mysql.url}"/>
<property name="username" value="${mysql.username}"/>
<property name="password" value="${mysql.password}"/>
</bean>
- 配置 JdbcTemplate 对象,注入 DataSource
<!-- 配置JdbcTemplate对象,注入DataSource -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
- 创建 service 类,创建 dao 类,在 dao 注入 jdbcTemplate 对象
- 配置文件
<!-- 组件扫描 --> <context:component-scan base-package="com.atguigu"></context:component-scan>
@Service
public class BookService {
//注入BookDao实现类对象
@Autowired
private BookDao bookDao;
}
public interface BookDao {}
@Component
public class BookDaoImpl implements BookDao{
//注入JdbcTemplate对象
@Autowired
private JdbcTemplate jdbcTemplate;
}
4.2、JdbcTemplate 操作数据库(添加)
(1)对应数据库创建实体类
package com.weeks.spring5.bean;
/**
* 这是一个javabean对应t_book表
*/
public class Book {
private Integer bookId;
private String bookName;
private String bookStatus;
public Book() {
}
public Book(Integer bookId, String bookName, String bookStatus) {
this.bookId = bookId;
this.bookName = bookName;
this.bookStatus = bookStatus;
}
public Integer getBookId() {
return bookId;
}
public void setBookId(Integer bookId) {
this.bookId = bookId;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public String getBookStatus() {
return bookStatus;
}
public void setBookStatus(String bookStatus) {
this.bookStatus = bookStatus;
}
@Override
public String toString() {
return "Book{" +
"bookId=" + bookId +
", bookName='" + bookName + '\'' +
", bookStatus='" + bookStatus + '\'' +
'}';
}
}
(2)编写 service 和 dao
- 在 dao 进行数据库添加操作
- 调用 JdbcTemplate 对象里面 update 方法实现添加操作
@Component
public class BookDaoImpl implements BookDao{
//注入JdbcTemplate对象
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public void addBook(Book book) {
//1 创建 sql 语句
String sql = "insert into t_book values(?,?,?)";
//2 调用方法实现
Object[] args = {book.getBookId(), book.getBookName(), book.getBookStatus()};
int rows = jdbcTemplate.update(sql, args);
System.out.println(rows);
}
}
(3)测试类
public class testJdbcTamplate {
@Test
public void testAdd(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService", BookService.class);
Book book = new Book(1001, "红楼梦", "可借");
bookService.add(book);
}
}
4.3、JdbcTemplate 操作数据库(修改和删除)
- 修改
@Override
public void updateBook(Book book) {
String sql = "update t_book set bookName=?, bookStatus=? where book_id=?";
Object[] args = {book.getBookName(), book.getBookStatus(),book.getBookId()};
int rows = jdbcTemplate.update(sql, args);
System.out.println(rows);
}
- 删除
@Override
public void deleteBookById(Integer id) {
String sql = "delete from t_book where book_id=?";
int rows = jdbcTemplate.update(sql, id);
System.out.println(rows);
}
4.4、JdbcTemplate 操作数据库(查询返回某个值)
- 查询表里面有多少条记录,返回是某个值
- 使用 JdbcTemplate 实现查询返回某个值代码
@Override
public int selectCount() {
String sql = "select count(*) from t_book";
Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
return count;
}
//测试代码
@Test
public void testSelect01(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService", BookService.class);
int i = bookService.selectOneObject();
System.out.println(i);
}
4.5、JdbcTemplate 操作数据库(查询返回对象)
- 场景:查询图书详情
- JdbcTemplate 实现查询返回对象
@Override
public Book selectBookById(Integer id) {
String sql = "select * from t_book where book_id=?";
Book book = jdbcTemplate.queryForObject(sql,
new BeanPropertyRowMapper<Book>(Book.class), id);
return book;
}
4.6、JdbcTemplate 操作数据库(查询返回集合)
- 场景:查询图书列表分页…
- 调用 JdbcTemplate 方法实现查询返回集合
@Override
public List<Book> selectAllBook() {
String sql = "select * from t_book";
List<Book> bookList = jdbcTemplate.query(sql,
new BeanPropertyRowMapper<Book>(Book.class));
return bookList;
}
4.7、JdbcTemplate 操作数据库(批量操作)
- 批量操作:操作表里面多条记录
- JdbcTemplate 实现批量添加操作
- JdbcTemplate 实现批量修改操作
- JdbcTemplate 实现批量删除操作
//批量插入
@Override
public int insertByBatch(List<Object[]> batchArgs) {
String sql = "insert into t_book values(?,?,?)";
int[] ints = jdbcTemplate.batchUpdate(sql,batchArgs);
return 0;
}
//批量更新
@Override
public int[] updateByBatch(List<Object[]> batchArgs){
String sql = "update t_book set bookName=?,bookStatus=? where book_id=?";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
return ints;
}
//批量删除
@Override
public int[] deleteByBatch(List<Object[]> batchArgs){
String sql = "delete from t_book where book_id=?";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
return ints;
}
4.8、代码汇总
package com.weeks.spring5.bean;
/**
* 这是一个javabean对应t_book表
*/
public class Book {
private Integer bookId;
private String bookName;
private String bookStatus;
public Book() {
}
public Book(Integer bookId, String bookName, String bookStatus) {
this.bookId = bookId;
this.bookName = bookName;
this.bookStatus = bookStatus;
}
public Integer getBookId() {
return bookId;
}
public void setBookId(Integer bookId) {
this.bookId = bookId;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public String getBookStatus() {
return bookStatus;
}
public void setBookStatus(String bookStatus) {
this.bookStatus = bookStatus;
}
@Override
public String toString() {
return "Book{" +
"bookId=" + bookId +
", bookName='" + bookName + '\'' +
", bookStatus='" + bookStatus + '\'' +
'}';
}
}
package com.weeks.spring5.dao;
import com.weeks.spring5.bean.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
package com.weeks.spring5.dao;
import com.weeks.spring5.bean.Book;
import java.util.List;
/**
* BookDao
*/
public interface BookDao {
public void addBook(Book book);
public void updateBook(Book book);
public void deleteBookById(Integer id);
public int selectCount();
public Book selectBookById(Integer id);
public List<Book> selectAllBook();
public int insertByBatch(List<Object[]> batchArgs);
public int[] updateByBatch(List<Object[]> batchArgs);
public int[] deleteByBatch(List<Object[]> batchArgs);
}
/**
* BookDaoImpl
*/
@Component
public class BookDaoImpl implements BookDao{
//注入JdbcTemplate对象
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public void addBook(Book book) {
String sql = "insert into t_book values(?,?,?)";
Object[] args = {book.getBookId(), book.getBookName(), book.getBookStatus()};
int rows = jdbcTemplate.update(sql, args);
System.out.println(rows);
}
@Override
public void updateBook(Book book) {
String sql = "update t_book set bookName=?, bookStatus=? where book_id=?";
Object[] args = {book.getBookName(), book.getBookStatus(),book.getBookId()};
int rows = jdbcTemplate.update(sql, args);
System.out.println(rows);
}
@Override
public void deleteBookById(Integer id) {
String sql = "delete from t_book where book_id=?";
int rows = jdbcTemplate.update(sql, id);
System.out.println(rows);
}
@Override
public int selectCount() {
String sql = "select count(*) from t_book";
Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
return count;
}
@Override
public Book selectBookById(Integer id) {
String sql = "select * from t_book where book_id=?";
Book book = jdbcTemplate.queryForObject(sql,
new BeanPropertyRowMapper<Book>(Book.class), id);
return book;
}
@Override
public List<Book> selectAllBook() {
String sql = "select * from t_book";
List<Book> bookList = jdbcTemplate.query(sql,
new BeanPropertyRowMapper<Book>(Book.class));
return bookList;
}
@Override
public int insertByBatch(List<Object[]> batchArgs) {
String sql = "insert into t_book values(?,?,?)";
int[] ints = jdbcTemplate.batchUpdate(sql,batchArgs);
return 0;
}
@Override
public int[] updateByBatch(List<Object[]> batchArgs){
String sql = "update t_book set bookName=?,bookStatus=? where book_id=?";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
return ints;
}
@Override
public int[] deleteByBatch(List<Object[]> batchArgs){
String sql = "delete from t_book where book_id=?";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
return ints;
}
}
package com.weeks.spring5.service;
import com.weeks.spring5.dao.BookDao;
import com.weeks.spring5.bean.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* BookService
*/
@Component
public class BookService {
//注入BookDao实现类对象
@Autowired
private BookDao bookDao;
//添加一条记录到t_book表
public void add(Book book){
bookDao.addBook(book);
}
//更新记录
public void update(Book book){
bookDao.updateBook(book);
}
//删除记录
public void delete(Integer id){
bookDao.deleteBookById(id);
}
//返回一个对象
public int selectOneObject(){
return bookDao.selectCount();
}
public Book selectABook(Integer id){
return bookDao.selectBookById(id);
}
public List<Book> selectBooks(){
return bookDao.selectAllBook();
}
public int inserts(List<Object[]> batches){
return bookDao.insertByBatch(batches);
}
public int[] updates(List<Object[]> batches){
return bookDao.updateByBatch(batches);
}
public int[] deletes(List<Object[]> batches){
return bookDao.deleteByBatch(batches);
}
}
package com.weeks.spring5.test;
import com.weeks.spring5.bean.Book;
import com.weeks.spring5.service.BookService;
import javafx.beans.binding.ObjectExpression;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
/**
* 测试代码
*/
public class testJdbcTamplate {
@Test
public void testAdd(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService", BookService.class);
Book book = new Book(1001, "红楼梦", "可借");
bookService.add(book);
}
@Test
public void testUpdate(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService", BookService.class);
Book book = new Book(1001, "水浒传", "借出");
bookService.update(book);
}
@Test
public void testDelete(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService", BookService.class);
bookService.delete(1001);
}
@Test
public void testSelect01(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService", BookService.class);
int i = bookService.selectOneObject();
System.out.println(i);
}
@Test
public void testSelect02(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService", BookService.class);
Book book = bookService.selectABook(1001);
System.out.println(book);
}
@Test
public void testSelect03(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService", BookService.class);
List<Book> books = bookService.selectBooks();
Iterator<Book> iterator = books.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
@Test
public void testInserts(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService", BookService.class);
Book book1 = new Book(1003, "三国演义", "借出");
Book book2 = new Book(1004, "平凡的世界", "可借");
Book book3 = new Book(1005, "围城", "借出");
Object[] object1 = {book1.getBookId(), book1.getBookName(), book1.getBookStatus()};
Object[] object2 = {book2.getBookId(), book2.getBookName(), book2.getBookStatus()};
Object[] object3 = {book3.getBookId(), book3.getBookName(), book3.getBookStatus()};
List<Object[]> objects = new ArrayList<>();
objects.add(object1);
objects.add(object2);
objects.add(object3);
int updates = bookService.inserts(objects);
}
@Test
public void testUpdates(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService", BookService.class);
Book book1 = new Book(1003, "三国演义-新", "借出");
Book book2 = new Book(1004, "平凡的世界-新", "可借");
Book book3 = new Book(1005, "围城-新", "借出");
Object[] object1 = {book1.getBookName(), book1.getBookStatus(), book1.getBookId()};
Object[] object2 = {book2.getBookName(), book2.getBookStatus(), book2.getBookId()};
Object[] object3 = {book3.getBookName(), book3.getBookStatus(), book3.getBookId()};
List<Object[]> objects = new ArrayList<>();
objects.add(object1);
objects.add(object2);
objects.add(object3);
int[] updates = bookService.updates(objects);
System.out.println(Arrays.toString(updates));
}
@Test
public void testDeletes(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService", BookService.class);
Object[] object1 = {1003};
Object[] object2 = {1004};
List<Object[]> objects = new ArrayList<>();
objects.add(object1);
objects.add(object2);
int[] updates = bookService.deletes(objects);
System.out.println(Arrays.toString(updates));
}
}
5、事务管理
5.1、事务操作(事务概念)
(1)什么是事务
- 事务是数据库操作最基本单元,逻辑上一组操作,要么都成功,如果有一个失败所有操作都失败
- 典型场景:银行转账
- lucy 转账 100 元 给 mary
- lucy 少 100,mary 多 100
(2)事务四个特性(ACID)
- 原子性
- 一致性
- 隔离性
- 持久性
5.2、事务操作(搭建事务操作环境)
(1)创建数据库表,添加记录
(2)创建 service,搭建 dao,完成对象创建和注入关系
- service 注入 dao,在 dao 注入 JdbcTemplate,在 JdbcTemplate 注入 DataSource
package com.weeks.spring5.dao;
public interface AccountDao {
//增加账户余额
public boolean addBalance(Integer id, Double addMoney);
//减少账户余额
public boolean subBalance(Integer id, Double subMoney);
}
@Repository
public class AccountDaoImpl implements AccountDao{
//注入JdbcTemplate对象属性值
@Autowired
private JdbcTemplate jdbcTemplate;
}
@Service
public class AccountService {
//注入AccountDao属性
@Autowired
private AccountDao accountDao;
}
(3)在 dao 创建两个方法:多钱和少钱的方法,在 service 创建方法(转账的方法)
package com.weeks.spring5.dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
@Repository
public class AccountDaoImpl implements AccountDao{
//注入JdbcTemplate对象属性值
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public boolean addBalance(Integer id, Double addMoney) {
String sql = "update t_account set balance=balance-? where id=?";
int update = jdbcTemplate.update(sql, addMoney, id);
return (update>0 ? true : false);
}
@Override
public boolean subBalance(Integer id, Double subMoney) {
String sql = "update t_account set balance=balance+? where id=?";
int update = jdbcTemplate.update(sql, subMoney, id);
return (update>0 ? true : false);
}
}
@Service
//@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.REPEATABLE_READ, timeout = 10)
public class AccountService {
//注入AccountDao属性
@Autowired
private AccountDao accountDao;
//实现转账的方法
public void transferAccounts(Integer[] ids, Double balance){
//一个账户减少余额
boolean add = accountDao.addBalance(ids[0], balance);
int i = 10 / 0;//模拟出现异常
//另一个账户增加余额
boolean sub = accountDao.subBalance(ids[1], balance);
if(add && sub){
System.out.println("transfer accounts success!");
}else{
System.out.println("transfer accounts fail!");
}
}
}
如果上面的代码出现异常可能导致账户的余额不正确。需要使用事务来解决。
(4)事务的操作过程
public void transferAccounts(){
try{
//第一步 开启事务
//第二步 进行业务操作
//一个账户减少余额
boolean sub = accountDao.subBalance(ids[1], balance);
//模拟异常发生
int i = 10 / 0;
//另一个账户增加余额
boolean add = accountDao.addBalance(ids[0], balance);
//第三步 没有异常发生,提交事务
}catch(Exception e){
//第四步 出现异常,事务回滚
}
}
5.3、事务操作(Spring 事务管理介绍)
(1)事务添加到 JavaEE 三层结构里面 Service 层(业务逻辑层)
(2)在 Spring 进行事务管理操作
- 有两种方式:编程式事务管理和声明式事务管理(使用)
(3)声明式事务管理
- 基于注解方式(使用)
- 基于 xml 配置文件方式
(4)在 Spring 进行声明式事务管理,底层使用 AOP 原理
(5)Spring 事务管理 API
- 提供一个接口,代表事务管理器,这个接口针对不同的框架提供不同的实现类
5.4、事务操作(注解声明式事务管理)
(1)在 spring 配置文件配置事务管理器
<!-- 配置事务管理器对象 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置JdbcTemplate对象,注入DataSource -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
(2)在 spring 配置文件,开启事务注解
- 在 spring 配置文件引入名称空间 tx
- 开启事务注解
<!--开启事务注解-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
(3)在 service 类上面(或者 service 类里面方法上面)添加事务注解
- @Transactional,这个注解添加到类上面,也可以添加方法上面
- 如果把这个注解添加类上面,这个类里面所有的方法都添加事务
- 如果把这个注解添加方法上面,为这个方法添加事务
@Service
@Transactional
public class AccountService {
5.5、事务操作(声明式事务管理参数配置)
(1)在 service 类上面添加注解@Transactional,在这个注解里面可以配置事务相关参数
(3)propagation:事务传播行为
- 多事务方法直接进行调用,这个过程中事务是如何进行管理的
@Service
@Transactional(propagation = Propagation.REQUIRED)
public class AccountService {
(4)ioslation:事务隔离级别
- 事务有特性成为隔离性,多事务操作之间不会产生影响。不考虑隔离性产生很多问题
- 有三个读问题:脏读、不可重复读、虚(幻)读
- 脏读:一个未提交事务读取到另一个未提交事务的数据
- 不可重复读:一个未提交事务读取到另一提交事务修改数据
- 虚读:一个未提交事务读取到另一提交事务添加数据
- 解决:通过设置事务隔离级别,解决读问题
@Service
@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.REPEATABLE_READ)
public class AccountService {
(5)timeout:超时时间
- 事务需要在一定时间内进行提交,如果不提交进行回滚
- 默认值是 -1 ,设置时间以秒单位进行计算
(6)readOnly:是否只读
- 读:查询操作,写:添加修改删除操作
- readOnly 默认值 false,表示可以查询,可以添加修改删除操作
- 设置 readOnly 值是 true,设置成 true 之后,只能查询
(7)rollbackFor:回滚
- 设置出现哪些异常进行事务回滚
(8)noRollbackFor:不回滚
- 设置出现哪些异常不进行事务回滚
5.6、事务操作(XML 声明式事务管理)
(1)在 spring 配置文件中进行配置
- 第一步 配置事务管理器
- 第二步 配置通知
- 第三步 配置切入点和切面
<?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"
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">
<!-- 开始注解扫描 -->
<context:component-scan base-package="com.weeks.spring5"/>
<context:property-placeholder location="mysql.properties"/>
<!--注入数据源-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${mysql.driver}"/>
<property name="url" value="${mysql.url}"/>
<property name="username" value="${mysql.username}"/>
<property name="password" value="${mysql.password}"/>
</bean>
<!-- 配置JdbcTemplate对象,注入DataSource -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置事务管理器对象 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置通知 -->
<tx:advice id="pt" transaction-manager="transactionManager">
<!--配置事务参数-->
<tx:attributes>
<!--指定哪种规则的方法上面添加事务-->
<tx:method name="transferAccounts" propagation="REQUIRED" isolation="REPEATABLE_READ"/>
</tx:attributes>
</tx:advice>
<!-- 配置切入点和切面 -->
<aop:config>
<!-- 切入点 -->
<aop:pointcut id="pc" expression="execution(* com.weeks.spring5.service.AccountService.transferAccounts(..))"/>
<!-- 切面 -->
<aop:advisor advice-ref="pt" pointcut-ref="pc"/>
</aop:config>
</beans>
5.7、事务操作(完全注解声明式事务管理)
- 创建配置类,使用配置类替代 xml 配置文件
package com.weeks.spring5.service;
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.sql.DataSource;
@Configuration //配置类
@ComponentScan(basePackages = "com.weeks") //组件扫描
@EnableTransactionManagement //开启事务
public class TXConfig {
//创建数据库连接池
@Bean
public DruidDataSource getDruidDataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///user_db");
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;
}
}