目录
Spring的框架概述
1、Spring是一个轻量级的开源的JavaEE框架
2、Spring可以解决企业应用开发的复杂性
3、Spring有两个核心 IOC 和 AOP
(1)IOC:控制反转,把创建对象的过程交给Spring进行管理
(2)AOP:面向切面,不修改源代码进行功能增强
4、Sprting特点:
(1)方便解耦,简化开发
(2)AOP编程的支持
(3)方便程序的测试
(4)方便集成各种优秀框架
(5)方便进行事物操作
(6)降低API开发难度
入门案例
1、下载Spring5
下载地址
https://repo.spring.io/ui/native/release/org/springframework/spring/
2、使用IDEA,创建普通Java工程
3、导入Spring5相关jar包
4、创建普通类,在类里创建普通方法
public class User {
public void add(){
System.out.println("add...");
}
}
5、创建Spring配置文件,在配置文件配置创建的对象
(1)Spring配置文件使用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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 配置User类对象创建-->
<bean id="user" class="com.angus.spring5.User"></bean>
</beans>
6、进行测试代码编写
public void testAdd(){
//1、加载Spring配置文件
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
//2 获取配置创建的对象
User user = context.getBean("user", User.class);
System.out.println(user);
user.add();
}
IOC容器
什么是IOC
- Inversion of Control 控制反转,把对象的创建和对象之间的调用过程,交给Spring进行管理
- 目的:为了耦合度降低
- 入门案例就是通过IOC实现
IOC底层原理
技术:xml解析、工厂模式、反射
IOC接口(BeanFactory)
1、IOC思想基于IOC容器完成,IOC容器底层就是对象工厂
2、Spring提供IOC容器实现两种方式:(两个接口)
(1)BeanFactory:IOC容器基本实现,是Spring内部的使用接口,不提供开发人员进行使用
*加载配置文件时不会创建对象,而在获取对象(使用)才去创建
(2)ApplicationContext:BeanFactory接口的子接口,提供更多更强大的功能,面向开发人员
*加载配置文件就会把在配置文件对象进行创建
3、ApplicationContext接口
两个实现类
FileSystemXmlApplicationContext 是电脑具体盘符路径
ClassPathXmlApplicationContext 是代码的类路径(/src)
Bean管理
Bean管理指的是两个操作
(1)Spring创建对象
(2)Spring注入属性
Bean管理操作有两种方式
(1)通过xml配置文件方式实现
(2)基于注解方式实现
IOC操作 Bean管理(基于xml)
1、基于xml方式创建对象
(1)在Spring配置文件中,使用Bean标签,标签里面添加对应属性,就可以实现对象创建
(2)在bean标签有很多属性,介绍常用的属性
*id属性:唯一标识
*class属性:类全路径(包类路径)
(3)创建对象时候,默认执行无参构造器方法完成对象创建
2、基于xml方式注入属性
(1)DI:依赖注入,就是注入属性
3、第一种方式:使用set方式注入
(1)创建类,定义属性及set方法
(2)在Spring配置文件配置对象创建,配置属性注入 <property>标签
4、第二种方式:使用有参数构造进行注入
(1)创建类,定义属性,及有参数的构造器
(2)在Spring配置文件中进行配置,构造器注入 <constructor-arg>标签
5、p名称空间注入
(1)使用p名称空间注入,可以简化基于xml配置方式
第一步 添加p名称空间在配置文件中
第二步 进行属性注入,在bean标签里面进行操作
IOC操作 Bean管理(xml注入其他类型属性)
1、字面量
(1)null值
(2)属性值包含特殊符号
2、注入属性-外部bean
(1)创建两个类,service类和dao类
(2)在service调用dao里的方法
(3)在Spring配置文件中进行配置
3、注入属性-内部bean
(1)一对多关系:部门和员工
一个部门可以有多个员工,一个员工属于一个部门
(2)在实体类之间表示一对多关系,员工表示所属部门,使用对象形式表示
//部门类
public class Dept {
private String dname;
public void setDname(String dname) {
this.dname = dname;
}
//员工类
public class Emp {
private String ename;
private String gender;
//员工属于某一个部门,使用对象形式表示
private Dept dept;
public void setDept(Dept dept) {
this.dept = dept;
}
public void setEname(String ename) {
this.ename = ename;
}
public void setGender(String gender) {
this.gender = gender;
}
}
(3)在Spring配置文件完成配置
4、注入属性-级联赋值
(1)第一种写法
(2)第二种写法
IOC操作 Bean管理(xml注入集合属性)
1、注入数组类型属性
2、注入List集合类型属性
3、注入Map集合类型属性
(1)创建类,定义数组、list、map、set类型属性,并生成对应set方法
(2)在Spring配置文件中进行配置
4、在集合中设置对象类型值
5、把集合注入部分提取出来
(1)在Spring配置文件中引入名称空间util
(2)使用util标签
IOC操作Bean管理(FactoryBean)
1、Spring有两种类型Bean,一种是普通bean,一种是工厂bean(FactoryBean)
2、普通bean:在配置文件定义bean类型就是返回类型
3、工厂bean:在配置定义bean类型可以和返回类型不一样
第一步 创建类,让这个类作为工厂bean,实现接口FactoryBean
第二部 实现接口里面的方法,在实现的方法中定义返回的bean类型
IOC操作Bean管理(bean作用域)
1、在Spring里面,设置创建bean实例是单实例还是多实例
2、在Spring里面,默认情况下,bean是单实例对象
3、如何设置单实例还是多实例
(1)在Spring配置文件bean标签里面有(scope)用于设置单实例还是多实例
(2)scope属性值
第一个值 默认值,singleton,表示是单实例对象
第二个值 prototype,表示是多实例对象
(3)singleton和prototype区别
第一 singleton单实例,prototype多实例
第二 设置scope值是singleton时候,加载spring配置文件时候就会创建单实例对象
设置scope值是prototye时候,不是在嘉爱spring配置文件时候创建对象,在调用getBean方法时候创建多实例对象
IOC操作 Bean管理(bean声明周期)
1、生命周期
(1)从对象创建到对象销毁的过程
2、bean声明周期
(1)通过构造器创建bean实例(无参构造器)
(2)为bean的属性设置值和对其他bean的引用(调用类中的set方法)
(3)调用bean的初始化的方法(需要进行配置初始化的方法)
(4)bean可以使用了(对象获取到了)、
(5)当容器关闭时候,调用bean的销毁的方法(需进行配置销毁的方法)
4、bean的后置处理器,bean声明周期有七步
(1)通过构造器创建bean实例(无参构造器)
(2)为bean的属性设置值和对其他bean的引用(调 用类中的set方法)
(3)把bean实例传递bean后置处理器的方法postProcessBeforeInitialization
(3)调用bean的初始化的方法(需要进行配置初始化的方法)
(5)把bean实例传递bean后置处理器的方法postProcessAftereInitialization
(6)bean可以使用了(对象获取到了)、
(7)当容器关闭时候,调用bean的销毁的方法(需进行配置销毁的方法)
5、演示添加后置处理器效果
(1)创建类,实现接口BeanPostProcessor,创建后置处理器
(2)在bean配置文件中添加后置处理器
结果:
IOC操作 Bean管理(xml自动装配)
1、什么是自动装配
(1)根据指定装配规则(属性名称或属性类型),Spring自动将匹配的属性值进行注入
2、演示自动装配过程
(1)根据属性名称自动注入 byName
(2)根据属性类型自动注入 byType
IOC操作 Bean管理(引用外部属性文件)
1、直接配置数据库信息
(1)配置德鲁伊连接池
(2)引入德鲁伊连接池依赖jar包
2、引入外部属性文件配置数据库连接池
(1)创建外部属性文件,properties属性文件
*引入context名称空间
(2)读取配置文件中内容
在Spring配置文件中使用标签引入外部属性文件
IOC操作 Bean管理(基于注解方式)
1、什么是注解
(1)注解是代码特殊标记,格式:@注解名称(属性名称=属性值,属性名称=属性值...)
(2)使用注解,注解作用在类上面,方法上面,属性上面
(3)使用注解目的:简化xml配置
2、Spring针对Bean管理中创建对象提供注解
(1)@Component
(2)@Service
(3)@Controller
(4)@Repository
**上面的四个注解功能是一样的,都可用来创建bean实例
3、基于注解方式实现对象创建
第一步 引入依赖
第二步 开启组件扫描
第三步 创建类 在类上面添加注解
第四步测试
4、开启组件扫描细节配置
5、基于注解方式实现属性注入
(1)@Autowired:根据属性类型进行自动装配
第一步 把service和dao对象创建,在service和dao类上面添加注解
第二步 把service注入dao对象,在service类添加dao类型属性,在属性上面使用注解
(2)@Qualifier:根据属性名称进行注入
这个@Qualifier注解的使用,和上面@Autowired一起使用
(3)@Resource:可以根据类型注入,可以根据名称注入
(4)@Value:注入普通类型属性
6、完全注解开发
(1)创建配置类,替代xml配置文件
(2)编写测试类
AOP
什么是AOP
- 面向切面(方面),利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
- 通俗描述,不通过修改源代码方式,在主干功能中添加新功能。
- 使用登录功能说明AOP
AOP底层原理
1、AOP底层使用动态代理
(1)有两种情况动态代理
第一种 有接口情况:使用JDK动态代理
- 创建接口实现类代理对象,增强类的方法
第二种 没有接口情况:使用CGLIB动态代理
- 创建子类的代理对象,增强类的方法
AOP(JDK动态代理)
1、使用JDK动态代理,使用Proxy类里面的方法
(1)调用newProxyInstance方法
方法有三个参数
loader
- 类加载器来定义代理类
interfaces
- 增强方法所在的类,这个类实现的接口列表
h
- 实现接口InvocationHandler,创建代理对象,写增强的方法
2、JDK动态代理代码
(1)创建interface接口,实现方法
(2)创建接口实现类,实现方法
(3)使用Proxy类创建接口代理对象
AOP术语
1、连接点
类里面哪些方法可以被增强,这些方法称为连接点
2、切入点
实际被真正增强的方法,称为切入点
3、通知(增强)
(1)实际增强的逻辑部分称为通知(增强)
(2)通知有多种类型
- 前置通知
- 后置通知
- 环绕通知
- 异常通知
- 最终通知
4、切面是动作
(1)把通知应用到切入点过程
AOP操作(准备工作)
1、Spring框架一般基于AspectJ实现AOP操作
(1)什么是AspectJ
AspectJ不是Spring组成部分,独立AOP框架,一般是把AspectJ和Spring框架一起使用,进行AOP操作
2、基于AspectJ实现AOP操作
(1)基于xml配置文件实现
(2)基于注解方式实现(使用)
3、在项目工程引入AOP相关依赖
4、切入点表达式
(1)切入点表达式作用:知道对哪个类里面的哪个方法进行增强
(2)语法结构
execution([权限修饰符] [返回类型] [类全路径] [方法名称] ([参数列表]))
举例1:对com.angus.dao.BookDao类里面的add进行增强
execution( * com.angus.dao.BookDao.add(...))
举例2:对com.angus.dao.BookDao类里面的所有的方法进行增强
execution( * com.angus.dao.BookDao. *(...))
举例2:对com.angus.dao包里面所有类,类里面的所有的方法进行增强
execution( * com.angus.dao. * . * (...))
AOP操作(AspectJ注解实现)*** 常用
1、创建类,在类里面定义方法
2、创建增强类(编写增强逻辑)
(1)在增强类里,创建方法,让不同方法代表不同通知类型
3、进行通知的配置
(1)在Spring配置文件中,开启注解扫描
(2)使用注解创建User和UserProxy对象
(3)在增强类上面添加注解@Aspect
(4)在Spring配置文件中开启生成配置对象
4、配置不同类型的通知
(1)在增强类的里面,在作为通知方法上面添加通知类型注解,使用切入点表达式配置
5、相同切入点抽取
6、有多个增强类对同一个方法进行增强,可以设置优先级
(1)在增强类上面添加注解@Order(数字类型值),值越小优先级越高
7、完全使用注解开发
(1)创建配置类,不需要创建xml文件
(2)测试
AOP操作(AspectJ配置文件) 不常用
1、创建两个类,增强类和被增强类,创建方法
2、在Spring配置文件,创建两个类的对象
3、在spring配置文件创建切入点
JdbcTemplate
1、什么是JdbcTemplate
(1)Spring框架对JDBC进行封装,使用JdbcTemplate方便实现对数据库操作
2、准备工作
(1)引入相关jar包
(2)在Spring配置文件配置数据库连接池
(3)配置JdbcTemplate对象,注入dataSource
(4)创建service类,创建dao类,在dao注入JdbcTemplate对象
- 配置文件
- Service
- Dao实现类
JdbcTemplate操作数据库(添加)
1、对应数据库创建实体类
2、编写service和dao
(1)在dao进行数据库添加操作
(2)调用JdbcTemplate对象里面的update方法实现添加操作
- 有两个参数
- 第一个参数,sql语句
- 第二个参数,可变参数,填充sql语句的占位符
测试
JdbcTemplate操作数据库(修改和删除)
- BookService
- BookDaoImpl
JdbcTemplate操作数据库(查询返回某个值)
1、查询表里面有多少条举例,返回值是某个值
2、使用JdbcTemplate实现查询返回某个值代码
第一个参数 sql语句 第二个参数 返回值类型Class
JdbcTemplate操作数据库(查询返回对象)
1、场景:查询图书详情
2、JdbcTemplate实现查询返回对象
- 第一个参数 sql语句
- 第二个参数 RowMapper是接口,针对返回不同类型数据,使这个接口里面实现类完成数据封装
- 第三个参数 可变参数,用来填充sql语句的占位符
JdbcTemplate操作数据库(查询返回集合)
1、场景:查询图书列表分页
2、调用JdbcTemplate的query方法实现查询返回集合
- 第一个参数 sql语句
- 第二个参数 RowMapper是接口,针对返回不同类型数据,使这个接口里面实现类完成数据封装
- 第三个参数 可变参数,用来填充sql语句的占位符
JdbcTemplate操作数据库(批量操作)
1、批量操作:操作表里面多条数据
2、JdbcTemplate实现批量添加操作
- 第一个参数 sql语句
- 第二个参数 List集合,添加多条记录的数据
测试
事务概念
1、什么是事务
(1)事务是数据库操作最基本单元,逻辑上的一组操作,要么都成功,如果有一个失败所有操作都失败
(2)典型场景:银行转账
2、事务四个特性(ACID)
(1)原子性
(2)一致性
(3)隔离性
(4)持久性
事务操作(搭建事务操作环境)
1、创建数据库表,添加记录
2、创建service,搭建dao,完成对象创建和注入关系
(1)service注入dao,在dao注入JdbcTemplate,在JdbcTemplate注入DataSource
@Service
public class UserService {
@Autowired
private UserDao userDao;
public void account(){
}
}
*********************************
public interface UserDao {
}
**********************************
@Repository
public class UserDaoImpl implements UserDao{
@Autowired
private JdbcTemplate jdbcTemplate;
}
3、在dao创建两个方法,多钱和少钱的方法,在service创建转账的方法
public interface UserDao {
void reduceMoney();
void addMoney();
}
------------------------------------------
@Repository
public class UserDaoImpl implements UserDao{
@Autowired
private JdbcTemplate jdbcTemplate;
//Tom转账100给Mary
@Override
public void reduceMoney() {
String sql = "update t_account set money=money-? where username = ?";
jdbcTemplate.update(sql,100,"Tom");
}
@Override
public void addMoney() {
String sql = "update t_account set money=money+? where username = ?";
jdbcTemplate.update(sql,100,"Mary");
}
}
------------------------------------------
@Service
public class UserService {
@Autowired
private UserDao userDao;
//转账的方法
public void account(){
userDao.reduceMoney();;
userDao.addMoney();
}
}
4、上面代码,如果正常执行没有问题,但如果代码执行过程中出现异常,产生问题
(1)上面问题如何解决
*使用事务进行解决
(2)事务操作基本过程
事务操作(Spring事务管理介绍)
1、事务一般添加到JaveEE三层结构里面Service层(业务逻辑层)
2、在Spring进行事务管理操作
(1)有两种方式,编程式事务管理和声明式事务管理(使用)
3、声明式事务管理
(1)基于注解方式
(2)基于xml配置文件方式
4、在Spring进行声明式事务管理,底层使用AOP
5、Spring事务管理API
(1)提供一个接口,代表事务管理器,这个接口针对不同框架提供不同实现类
事务操作(注解声明式事务管理)
1、在Spring配置文件配置事务管理器
2、在Spring配置文件,开启事务注解
(1)在Spring配置文件,引入名称空间 tx
(2)开事务注解
3、在Service类上面*(或service类方法上面)添加事务注解
(1)@Transactional,这个注解添加到类上面,也可以添加到方法上面
(2)如果这个注解添加到类上面,这个类里所有方法都添加事务
(3)如果这个注解添加到方法上面,为这个方法添加事务
事务操作(声明式事务管理参数配置)
1、在Service类上添加注解@Transactional,在这个注解里面可以配置事务相关配置
2、propagation:事务传播行为
(1)多事务方法之间进行调用,这个过程中事务是如何进行管理的
3、ioslation:事务隔离级别
(1)事务有特性成为隔离性,多事务操作之间不会产生影响。不考虑隔离性产生很多问题
(2)有三个读问题:脏读、不可重复读、虚(幻)读
(3)脏读:一个未提交事务读取到另一个未提交事务的数据
(4)不可重复读:一个未提交事务读取到另一提交事务修改数据
(5)虚读:一个未提交事务读取到另一提交事务添加数据
(6)解决:通过设置事务隔离级别,解决读问题
4、timeout:超时时间
(1)事务需要在一定时间内进行提交,如果不提交进行回滚
(2)默认值是 -1 ,设置时间以秒单位进行计算
5、readOnly:是否只读
(1)读:查询操作,写:添加修改删除操作
(2)readOnly 默认值 false,表示可以查询,可以添加修改删除操作
(3)设置 readOnly 值是 true,设置成 true 之后,只能查询
6、rollbackFor:回滚
(1)设置出现哪些异常进行事务回滚
7、noRollbackFor:不回滚
(1)设置出现哪些异常不进行事务回滚
事务操作(基于XML配置文件声明式事务管理)
1、在 spring 配置文件中进行配置
第一步 配置事务管理器
第二步 配置通知
第三步 配置切入点和切面
事务操作(完全注解声明式事务管理)
1、创建配置类,使用配置类替代 xml 配置文件
@Configuration //配置类
@ComponentScan(basePackages = {"com.angus.spring5"})//组件扫描
@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){
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;
}
}
Spring5框架新功能
1、整个 Spring5 框架的代码基于 Java8,运行时兼容 JDK9,许多不建议使用的类和方
法在代码库中删除
2、Spring 5.0 框架自带了通用的日志封装
(1)Spring5 已经移除 Log4jConfigListener,官方建议使用 Log4j2
(2)Spring5 框架整合 Log4j2
第一步 引入 jar 包
第二步 创建 log4j2.xml 配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status用于设置log4j2自身内部的信息输出,可以不设置,当设置成trace时,可以看到log4j2内部各种详细输出-->
<configuration status="INFO">
<!--先定义所有的appender-->
<appenders>
<!--输出日志信息到控制台-->
<console name="Console" target="SYSTEM_OUT">
<!--控制日志输出的格式-->
<PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
</console>
</appenders>
<!--然后定义logger,只有定义了logger并引入的appender,appender才会生效-->
<!--root:用于指定项目的根日志,如果没有单独指定Logger,则会使用root作为默认的日志输出-->
<loggers>
<root level="info">
<appender-ref ref="Console"/>
</root>
</loggers>
</configuration>
3、Spring5 框架核心容器支持@Nullable 注解
(1)@Nullable 注解可以使用在方法上面,属性上面,参数上面,表示方法返回可以为空,属性值可以 为空,参数值可以为空
(2)注解用在方法上面,方法返回值可以为空
(3)注解使用在方法参数里面,方法参数可以为空
(4)注解使用在属性上面,属性值可以为空
4、Spring5 核心容器支持函数式风格 GenericApplicationContext
//函数式风格创建对象,交给 spring 进行管理
@Test
public void testGenericApplicationContext() {
//1 创建 GenericApplicationContext 对象
GenericApplicationContext context = new GenericApplicationContext();
//2 调用 context 的方法对象注册
context.refresh();
context.registerBean("user1",User.class,() -> new User());
//3 获取在 spring 注册的对象
// User user = (User)context.getBean("com.atguigu.spring5.test.User");
User user = (User)context.getBean("user1");
System.out.println(user);
}
5、Spring5 支持整合 JUnit5
(1)整合 JUnit4
第一步 引入 Spring 相关针对测试依赖
第二步 创建测试类,使用注解方式完成
@RunWith(SpringJUnit4ClassRunner.class) //单元测试框架
@ContextConfiguration("classpath:bean1.xml") //加载配置文件
public class JTest4 {
@Autowired
private UserService userService;
@Test
public void test1() {
userService.accountMoney();
}
}
(2)Spring5 整合 JUnit5
第一步 引入 JUnit5 的 jar 包
第二步 创建测试类,使用注解完成
@ExtendWith(SpringExtension.class)
@ContextConfiguration("classpath:bean1.xml")
public class JTest5 {
@Autowired
private UserService userService;
@Test
public void test1() {
userService.accountMoney();
}
}
(3)使用一个复合注解替代上面两个注解完成整合
@SpringJUnitConfig(locations = "classpath:bean1.xml")
public class JTest5 {
@Autowired
private UserService userService;
@Test
public void test1() {
userService.accountMoney();
}
}