spring-nfjh
Spring Xml 文件报红第一时间检查set 、get 、构造方法
准备工作
- JDK 最低版本17
- 设置Maven
- 见[王鹤老师的笔记]
本套Spring教程与其他Spring教程的区别可总结为以下几点：
第一点：手写Spring框架
第二点：手写组件扫描器
第三点：依赖倒置原则DIP
第四点：CGLIB动态代
§1 Spring启示录
当前项目
dao
UserDao
impl
UserDaoImpl_1
service
UserService
impl
UserServiceimpl_1
web
UserAction
service为了调用dao层方法,有dao层接口的实现类
web为了调用service层方法,有service层接口的实现类
缺点
若用户提出需求,程序员对项目的功能进行拓展时,就需要更改多层已经运行正常的的代码,不符合软件开发的“开闭原则”[OCP],即对扩展开放,对修改关闭
同时,也违背了“依赖倒置原则”
思想与解决方案
违背依赖倒置
上层依赖下层 : 上层因下层的改动而改动
[这样不好,违背依赖倒置原则！！！]
符合依赖倒置:
上不依赖下,"面向接口编程"
依赖倒置原则的目的,降低程序的耦合度，提高扩展力
解决思想:[控制反转]
只保留接口,把创建对象的的权利、以及对象的维护权利交出
- 重点:"让出权利"
- 出现的比较新,没有被纳入GoF23种设计模式中
解决方案:依赖注入[DI]
何如实现控制反转?
- 第一种：set注入（执行set方法给属性赋值）
- 第二种：构造方法注入（执行构造方法给属性赋值）
依赖：A对象和B对象的关系。
注入：是一种手段，通过这种手段，可以让A对象和B对象产生关系。
依赖注入：对象A和对象B之间的关系，靠注入的手段来维护。而注入包括：set注入和构造注入
控制反转是思想。依赖注入是这种思想的具体实现。
Spring是一个实现了IoC思想的容器。
注意术语：
| 术语 | - | - | 全称 |
|---|---|---|---|
| OCP | 开闭原则 | 开发原则 | Open Close Principle |
| DIP | 依赖倒置原则 | 开发原则 | Dependence Inversion Principle |
| IoC | 控制反转思想 | 一种新型的设计模式 | Inversion of Control |
| DI | 依赖注入 | 控制反转思想的具体实现方式 | Dependency Injection |
§2 Spring 简述
SSM
Spring
SpringMVC
Mybatis
面向切面编程:[蓉姐]
AOP（Aspect Orient Programming），面向切面编程。
切面:公共的,通用的,重复的功能称为切面,面向切面编程就是将切面提取出来,单独开发,在需要调用的方法中通过动态代理的方式进行织入
1)切面:就是那些重复的,公共的,通用的功能称为切面,例如:日志,事务,权限.
2)连接点:就是目标方法.因为在目标方法中要实现目标方法的功能和切面功能.
3)切入点(Pointcut):指定切入的位置,多个连接点构成切入点.切入点可以是一个目标方法,可以是一个类中的所有方法,可以是某个包下的所有类中的方法.
4)目标对象:操作谁,谁就是目标对象.
5)通知(Advice):来指定切入的时机.是在目标方法执行前还是执行后还是出错时,还是环绕目标方法切入切面功能.
§3 Spring 入门程序
1、代码编程步骤
基本结构
1-创建一个maven项目
补充项目结构
resources 并设置为 资源文件夹
同理补充测试资源文件夹
2-修改pom.xml文件
删除build标签
添加 spring框架需要的核心依赖 spring-context
如果没有jutil 包则添加
刷新pom.xml文件
Spring6未正式发布需要添加Spring提供的仓库地址
Add the following to resolve milestone and RC versions – for example, `6.0.0-M2` or `6.0.0-RC1`:
<repository>
<id>repository.spring.milestone</id>
<name>Spring Milestone Repository</name>
<url>https://repo.spring.io/milestone</url>
</repository>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.0-M2</version>
</dependency>
当加入spring context的依赖之后，会关联引入其他依赖：
spring aop：面向切面编程
spring beans：IoC核心
spring core：spring的核心工具包
spring jcl：spring的日志包
spring expression：spring表达式
3-创建项目所需的咖啡豆[无参构造、setXXX方法]
一定得有无参构造,底层使用的是反射机制通过无参构造创建对象
4-applicationContext.xml文件
- 配置文件放在resources类根路径下,可移植性高
- IDEA支持spring配置文件,有模板!!
- 在XML Configuration File → Spring Config
- 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">
<!--
<bean id="userBean" class="com.nfjh.spring6.bean.User">
</bean>
id是bean的唯一标识,不能重复
class 是 对应bean类的全限定类名
-->
<bean id="" class="">
<property name="" value=""/>
<property name="" ref=""/>
<!--
㊟:value 为简单类型赋值
ref 为引用类型赋值,且要求当前bean工厂中存在该引用类型对象
ref中填写的是bean的id
-->
</bean>
</beans>
㊟:value 为简单类型赋值
ref 为引用类型赋值,且要求当前bean工厂中存在该引用类型对象
5- 创建测试方法
创建工厂
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml路径");
//此处的构造方法是可变长参数,所以如果有多个可以直接加
/*此处有多个重载方法
public ClassPathXmlApplicationContext(String... configLocations) throws BeansException {
this(configLocations, true, (ApplicationContext)null);
}
若项目为普通项目,不是maven的,此处出现了错误
㊟:检查是否将resources 设置为资源文件夹
*/
//返回Object
User user = (User) applicationContext.getBean("userBean");
/*
另一种写法: 直接返回的就是我们需要的类型
在传入id的同时传入类型
User user = applicationContext.getBean("userBean", User.class);
*/
项目文件的修改与导入
1、删除target文件夹
2、删除 .iml 文件
3、修改pom.xml文件中的坐标
<artifactId>MVC_SpringXml</artifactId>
修改为项目名
4、导入
Project Structure
→ Modules
→ +
→ import Modules
→ 选中项目的根路径
→ import module from external model
→ maven
→ 一直next即可
§4 Spring对IoC的实现
实现依赖注入
set注入是在对象创建之后执行
构造注入是在对象实例化的过程中执行的
set注入
- javaBean中存在符合命名规范的set方法
- applicationContext.xml文件中进行了配置
<bean id="userDaoBean" class="com.nfjh.spring6.dao.UserDao" />
<bean id="userService" class="com.nfjh.spring6.service.UserService">
<property name="userdao" ref="userDaoBean"/>
</bean>
- 启动Spring容器，解析spring.xml文件，并且实例化所有的bean对象，放到spring容器当中。
- 根据bean的id从Spring容器中获取这个对象。
<!--
name 是setXxx()方法的xxx
㊟:value 为简单类型赋值
ref 为引用类型赋值,且要求当前bean工厂中存在该引用类型对象
ref中填写的是bean的id
-->
<bean id="" class="">
<property name="" value=""/>
<property name="" ref=""/>
</bean>
public class UserDao {
private static final Logger logger = LoggerFactory.getLogger(UserDao.class);
public void insert(){
logger.debug("保存信息到数据库!\n");
}
}
public class UserService {
private UserDao userdao;
public void setUserdao(UserDao userdao) {
this.userdao = userdao;
}
public void saveUser(){
userdao.insert();
}
@Test
public void testInsert(){
ApplicationContext applicationContext = (ApplicationContext) new ClassPathXmlApplicationContext("spring-core.xml");
UserService userService = applicationContext.getBean("userService", UserService.class);
userService.saveUser();
}
<bean id="userDao" class="com.nfjh.spring6.dao.UserDao" />
<bean id="userService" class="com.nfjh.spring6.service.UserService">
<property name="userdao" ref="userDao"/>
</bean>
构造注入
- javaBean中存在构造方法
<bean id="userDaoBean" class="com.nfjh.spring6.dao.UserDao" />
<bean id="customerServiceBean" class="com.nfjh.spring6.service.CustomerService">
<constructor-arg index="0" ref="userDaoBean"/>
</bean>
- applicationContext.xml文件中进行了配置
- 启动Spring容器，解析spring.xml文件，并且实例化所有的bean对象，放到spring容器当中。
- 根据bean的id从Spring容器中获取这个对象。
set注入的方式
使用set方法进行注入,一定得有无参构造,不要因为写了有参数的构造方法,
让无参数的方法被覆盖了,这时需要手动添加无参构造
| 注入方式 | 类类型 | 操作记忆 bean[id & class] > | 操作对象 |
|---|---|---|---|
| 外部Bean | 简单 | property[name & value] | 简单类型 attrName; |
| 引用 | property[name & ref] | bean[id & class] | |
| 内部Bean | --- | property[name] > bean[class] | bean[id & class] OR 简单类型 attrName; |
| 级联属性 | 引用 | property[name="注入类的属性名" & ref] + property[name="注入类的属性名.属性名" & value] | bean[id & class] |
| 数组 | 简单 | property[name] > array > value | 简单类型[] attrName; |
| 引用 | property[name] > array > ref[bean] | 引用类型[] attrName; | |
| List/Set | 简单 | property[name] > list/set > value | List/Set<简单类型> attrName; |
| 引用 | property[name] > list/set > ref[bean] | List/Set <引用类型> attrName; | |
| Map | Map | property[name] > map > entry[key/key-ref &value/value-ref] | Map<类型1,类型2> attrName; |
| Perperties | Perperties | property[name] > props > prop[key] | Map<String,String> |
| null | --- | property[name] > null单标签 | bean[id & class] OR 简单类型 attrName; |
| --- | 对哪个属性注入null值,就啥都不写 | bean[id & class] OR 简单类型 attrName; | |
| 空字符串 | String | property[name & value=""] | String |
| String | property[name] > value单标签 | String | |
| 特殊符号 | property[name & value="实体符号"] | ||
property[name] > value{ <![CDATA[值]]>} |
| 注入方式 | 类类型 | 操作记忆 | 操作对象 |
|---|---|---|---|
| p 命名空间 | 简单 | bean[id & class & p:属性名="属性值" ] | 简单类型 attrName; |
| 引用 | bean[id & class & p:属性名-ref="bean的id"] | bean[id & class] | |
xmlns:p="http://www.springframework.org/schema/p" |
|||
| c 命名空间 | 简单_属性名 | bean[id & class c:属性名="属性值"] | 简单类型 attrName; |
| 简单_下标 | bean[id & class c:_0="属性值"] |
简单类型 attrName; | |
| 引用_属性名 | bean[id & class c:属性名-ref="bean的id"] | bean[id & class] OR 简单类型 attrName; | |
| 引用_下标 | bean[id & class c:_0-ref="bean的id"] |
bean[id & class] OR 简单类型 attrName; | |
xmlns:c="http://www.springframework.org/schema/c" |
|||
| util命名空间 | List | bean[id & class] > property[name & ref="util的id"] | util:list[id] > value |
| util命名空间 | Set | -- 同List -- | util:set[id] > value |
| util命名空间 | Properties | -- 同List -- | util:properties[id] > prop[key] |
外部Bean
就是使用ref属性来引入。这就是注入外部Bean
<!--声明/定义Bean-->
<bean id="orderDaoBean" class="com.powernode.spring6.dao.OrderDao"></bean>
<bean id="orderServiceBean" class="com.powernode.spring6.service.OrderService">
<!--使用ref属性来引入。这就是注入外部Bean-->
<property name="orderDao" ref="orderDaoBean"/>
</bean>
内部bean
<!--内部bean-->
<!--Ctrl + Alt + Shift + C-->
<bean id="osBeanIn" class="com.nfjh.spring6.service.OrderService">
<property name="orderDao">
<bean class="com.nfjh.spring6.dao.OrderDao"/>
</property>
</bean>
内部bean在定义的时候放在 property标签中
property标签中不加 ref
bean标签中不加 id
简单类型注入
<!--注入简单类型-->
<bean id="userBean" class="com.nfjh.spring6.bean.User">
<property name="username" value="zhangsan"/>
<property name="passwd" value="123"/>
<property name="age" value="20"/>
</bean>
哪些是简单类型
双击shift → BeanUtils → Ctrl + F12
isSimpleType()
对于Date是简单类型,但是需要严格按照格式写日期,不急麻烦
在平常使用时直接当成引用类型,使用ref进行注入
- 基本数据类型
- 基本数据类型对应的包装类
- String或其他的CharSequence子类
- Number子类
- Date子类
- Enum子类
- URI
- URL
- Temporal子类
- Locale
- Class
- 另外还包括以上简单值类型对应的数组类型。
简单类型可以用于对数据源信息的注入
级联属性
User
private String username;
private String passwd;
private int age;
以及对应的get set toString方法
Client
private User user;
private String clientName;
以及对应的get set toString方法
<!--级联属性赋值-->
<bean id="userBeanCascade" class="com.nfjh.spring6.bean.User"/>
<bean id="clientBean" class="com.nfjh.spring6.bean.Client">
<property name="clientName" value="QQ"/>
<!--使用级联属性赋值,Client 中要有getUser()方法-->
<property name="user" ref="userBeanCascade"/>
<!--使用级联属性赋值,user必须要有对应的username、passwd、age get方法-->
<property name="user.username" value="张三"/>
<property name="user.passwd" value="123456"/>
<property name="user.age" value="21"/>
</bean>
注入数组
Lseeon
private String [] lessonName ;
以及对应的set toString方法
Student
private String name;
private Lesson [] lessons;
以及对应的set toString方法
<!--
简答类型数组注入
property > array > value
private String [] lessonName ;-->
<bean id="lessonBean" class="com.nfjh.spring6.bean.Lesson">
<property name="lessonName">
<array>
<value>JAVA</value>
<value>MYBATIS</value>
<value>SPRING</value>
</array>
</property>
</bean>
<bean id="lessonBean2" class="com.nfjh.spring6.bean.Lesson">
<property name="lessonName">
<array>
<value>MYSQL</value>
<value>JDBC</value>
<value>AJAX</value>
</array>
</property>
</bean>
<!--
......
Lesson lessonBean = applicationContext.getBean("lessonBean", Lesson.class);
System.out.println(lessonBean);
//Lesson{lessonName=[JAVA, MYBATIS, SPRING]}
-->
<!--引用类型数组注入
private String name;
private Lesson [] lessons;
property > array > ref[bean]
-->
<bean id="studentBean" class="com.nfjh.spring6.bean.Student">
<property name="name" value="张三"/>
<property name="lessons">
<array>
<ref bean="lessonBean"/>
<ref bean="lessonBean2"/>
</array>
</property>
</bean>
<!--
......
Student studentBean = applicationContext.getBean("studentBean", Student.class);
System.out.println(studentBean);
//Student{name='张三', lessons=[Lesson{lessonName=[JAVA, MYBATIS, SPRING]}, Lesson{lessonName=[MYSQL, JDBC, AJAX]}]}
-->
List 和Set集合注入
Person
private List<User> userList;
private Set<User> userSet;
以及对应的set toString方法
<!--
㊟:List中的元素可以重复
Set中的元素如果重复写,不报错,但是相同元素只算1个
-->
<!--List注入
简单类型
property > list > value
引用类型
property > list > ref[bean]
-->
<!-- set注入
简单类型
property > list > value
引用类型
property > list > ref[bean]
-->
<bean id="personBean" class="com.nfjh.spring6.bean.Person">
<property name="userList">
<list>
<ref bean="userBean"/>
<ref bean="userBeanCascade"/>
</list>
</property>
</bean>
<!--
//Person{userList=[User{username='zhangsan', passwd='123', age=20}, User{username='张三', passwd='123456', age=21}], userSet=null}
//通过此程序可以得知
//通过级联属性赋值的bean可以通过 id 实例化,拿到其中的值
-->
<bean id="personBean2" class="com.nfjh.spring6.bean.Person">
<property name="userList">
<list>
<ref bean="userBean"/>
<ref bean="userBeanCascade"/>
</list>
</property>
<property name="userSet">
<set >
<ref bean="userBean"/>
<ref bean="userBeanCascade"/>
</set>
</property>
</bean>
<!--
Person{userList=[User{username='zhangsan', passwd='123', age=20}, User{username='张三', passwd='123456', age=21}], userSet=[User{username='zhangsan', passwd='123', age=20}, User{username='张三', passwd='123456', age=21}]}
-->
Map 注入
还是person
再加上一个属性
private Map<Integer,User> userMap;
以及对应的set toString方法
<!--Map注入
简单类型
property > map > entry[key & value]
引用类型
property > map > enter[key-ref & value-ref]
-->
<bean id="personMapBean" class="com.nfjh.spring6.bean.Person">
<property name="userMap">
<map>
<entry key="1" value-ref="userBean"/>
<entry key="2" value-ref="userBeanCascade"/>
</map>
</property>
</bean>
<!--
......
Person personMapBean = applicationContext.getBean("personMapBean", Person.class);
System.out.println(personMapBean);
//Person{userList=null, userSet=null, userMap={1=User{username='zhangsan', passwd='123', age=20}, 2=User{username='张三', passwd='123456', age=21}}}
-->
Perperties类型注入
/*虽然properties也是Map但是他的注入方式与Map不同*/
还是person
再加上一个属性
Properties properties ;
以及对应的set toString方法
<!--特殊Map类型Properties类型注入
property > props > prop[key](内容)
-->
<bean id="personProBean" class="com.nfjh.spring6.bean.Person">
<property name="properties" >
<props>
<!--注意 prop的key 与值都是String类型-->
<prop key="driver">com.nfjh.hello</prop>
<prop key="url">www.baidu.com</prop>
</props>
</property>
</bean>
<!--
......
Person personProBean = applicationContext.getBean("personProBean", Person.class);
System.out.println(personProBean);
//Person{userList=null, userSet=null, userMap=null, properties={driver=com.nfjh.hello, url=www.baidu.com}}
-->
注入null
User
private String username;
private String passwd;
private int age;
以及对应的get set toString方法
<!--null值的注入-->
<bean id="userNullBean" class="com.nfjh.spring6.bean.User">
<!--第一种注入方式,不注入自动注入null-->
<!--此处不给age 注入值-->
<!--第二中注入方式,手动注入null-->
<property name="username">
<null/>
</property>
<!--错误的注入,这种是注入了"null"字符串,不是注入正真的null-->
<property name="passwd" value="null"/>
</bean>
<!--
......
User userNullBean = applicationContext.getBean("userNullBean", User.class);
System.out.println(userNullBean);
System.out.println(userNullBean.getPasswd().toUpperCase());
/*
User{username='null', passwd='null', age=0}
NULL
对于第三种错的注入的解释:
如果 真的注入的是null的话,此处应该报空指针异常
但运行结果确实"null"字符串被转化成了大写的字母
所以未注入成功null
另外对于age属性,我的却没有注入值
但结果却是0 ,这点需要注意
*/
-->
注入空字符串
还是User
<!--
空字符串的注入
-->
<!--null值的注入-->
<bean id="userStrNullBean" class="com.nfjh.spring6.bean.User">
<!--第一种注入方式 value中不给值即可-->
<property name="username" value=""/>
<!--第二中注入方式,手动标签注入""-->
<property name="passwd">
<value/>
</property>
</bean>
<!--
......
User userStrNullBean = applicationContext.getBean("userStrNullBean", User.class);
System.out.println(userStrNullBean);
//User{username='', passwd='', age=0}
-->
< " ' & > 5个特殊符号的注入
<!--特殊符号的注入-->
<bean id="specialSymbolsBean" class="com.nfjh.spring6.bean.User">
<!--第一种:只用实体符号
这里就之列出一种
> >
<property name="username" value="2 < 3"/>
-->
<property name="username" value="2 > 3"/>
<!--第二种:使用value标签 + <![CDATA[2<3]]>-->
<property name="passwd">
<value> <![CDATA[2<3]]> </value>
</property>
<!--
注意点1：
要使用value标签直接放在value中是不对的!!!!
<property name="passwd" value="<![CDATA[2<3]]>"/>
注意点2：
<value></value>中的内容为注入的内容
所以如果这么写结果为
<property name="passwd">
<value>
<![CDATA[2<3]]>
</value>
</property>
User{username='2 > 3', passwd='
2<3
', age=0}
注意点3:
<![CDATA[]]> 中的字符全部要大写
注意点:
不管是使用实体符还是!<[CDATA[]]>这都是XML的语法
-->
</bean>
<!--
User specialSymbolsBean = applicationContext.getBean("specialSymbolsBean", User.class);
System.out.println(specialSymbolsBean);
//User{username='2 > 3', passwd=' 2<3 ', age=0}
-->
小结
外部bean
<property name="orderDao" ref="orderDaoBean"/>
p命名空间注入
p命名空间注入的底层还是"set"注入
所以仍然需要提供set方法
只不过这种注入方式会让spring配置更加简单
xmlns:p="http://www.springframework.org/schema/p"
User
private String username;
private String passwd;
private int age;
以及对应的get set toString方法
Client
private User user;
private String clientName;
以及对应的get set toString方法
<!--
p命名空间
1、修改头部
添加 xmlns:p="http://www.springframework.org/schema/p"
2、直接使用
简单类型
p:属性名="属性值"
引用类型
p:属性名-ref="bean的id"
-->
<bean id="userBean" class="com.nfjh.spring6.bean.User" p:age="0" p:passwd="haha" p:username="zhangsan"/>
<bean id="clientBean" class="com.nfjh.spring6.bean.Client" p:clientName="QQ" p:user-ref="userBean"/>
<!--
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("p-namespace.xml");
Client clientBean = applicationContext.getBean("clientBean", Client.class);
System.out.println(clientBean);
//Client{user=User{username='zhangsan', passwd='haha', age=0}, clientName='QQ'}
-->
c 命名空间注入
c命名空间注入的底层还是"构造"注入
所以仍然需要提供构造方法
只不过这种注入方式会让spring配置更加简单
修改就不说了,上面改p的这里改成 c 就行了
xmlns:c="http://www.springframework.org/schema/c"
Shop
private String address;
private String name;
private Date businessHours;
以及对应的三个参数构造方法
<bean id="date" class="java.util.Date"/>
<!--
<bean id="shopBean" class="com.nfjh.spring6.bean.Shop" c:_0="天津市" c:_1="小张水果" c:_2-ref="date"/>
-->
<bean id="shopBean" class="com.nfjh.spring6.bean.Shop" c:address="天津市" c:name="小张水果" c:businessHours-ref="date"/>
<!--
对于c命名空间
可以使用参数下标对参数赋值,也可以使用属性名对参数赋值
Shop shopBean = applicationContext.getBean("shopBean", Shop.class);
System.out.println(shopBean);
//Shop{address='天津市', name='小张水果', businessHours=Fri Oct 28 06:35:03 CST 2022}
-->
util命名空间
简化集合 Map ,提高代码复用率
第一步:和p一样修改
第二步:在第三行的引号中追加
使用
<util:TYPE id="">
.....
</util:TYPE>
Book
private List<String> name;
private Set<String> ISBN;
private Properties type;
以及对应的set toString方法
<util:list id="bookList">
<value>三体</value>
<value>活着</value>
</util:list>
<util:set id="bookSet">
<value>1211121</value>
<value>22332232</value>
</util:set>
<util:properties id="bookProp">
<prop key="1">科幻</prop>
<prop key="2">文学</prop>
</util:properties>
<bean id="bookBean" class="com.nfjh.spring6.bean.Book">
<property name="name" ref="bookList"/>
<property name="ISBN" ref="bookSet"/>
<property name="type" ref="bookProp"/>
</bean>
<util:list id="bookList2">
<value>流浪地球</value>
<value>诗经</value>
</util:list>
<bean id="bookBean2" class="com.nfjh.spring6.bean.Book">
<property name="name" ref="bookList2"/>
<property name="ISBN" ref="bookSet"/>
<property name="type" ref="bookProp"/>
</bean>
基于XML的自动装配
不管是使用 autowire="byName"
还是autowire="byType"
底层都是使用set方法
User
private String username;
private String passwd;
private int age;
以及对应的get set toString方法
Client
private User user;
private String clientName;
以及对应的get set toString方法
autowire="byName"
<!--根据名称自动装配
1、添加 autowire属性
2、被装配的bean的id必须是setXxx()方法的xxx
-->
<bean id="clientBean" class="com.nfjh.spring6.bean.Client" autowire="byName">
<property name="clientName" value="QQ"/>
<!--
这里没有了
<property name="user" ref="..."/>
-->
</bean>
<!--这里的id不能随便写了-->
<bean id="user" class="com.nfjh.spring6.bean.User">
<property name="age" value="20"/>
<property name="passwd" value="1221"/>
<property name="username" value="zhangsan"/>
</bean>
autowire="byType"
User 中添加该方法
public void testAutoWire(){
System.out.println("user对象已经实例化");
}
<!--
根据类型进行自动进行装配
1、添加 autowire属性 值为 byType
2、被装配的bean可以没有id,且只能有一个实例,如果有多个就会出现错误
3、如果xml文件中只有一个bean,但是爆红了,不用管,因为Spring扫描的是全部的xml文件
可以降低xml文件的报红的级别,让他不报红,或者直接不管
-->
<!--
<bean class="java.util.Date"/>
Date类型注入失败,为null
怀疑是普通类型,不走byType进行注入
-->
<bean id="user" class="com.nfjh.spring6.bean.User">
<property name="age" value="20"/>
<property name="passwd" value="1221"/>
<property name="username" value="zhangsan"/>
</bean>
<bean id="clientBean2" class="com.nfjh.spring6.bean.Client" autowire="byType">
<property name="clientName" value="QQ"/>
</bean>
<!--
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("autowire.xml");
Client clientBean = applicationContext.getBean("clientBean2", Client.class);
clientBean.getUser().testAutoWire();;
System.out.println(clientBean);
//user对象已经实例化
//Client{user=User{username='zhangsan', passwd='1221', age=20}, clientName='QQ'}
-->
spring引入外部属性配置文件
步骤
1、准备jdbc.properties文件
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:2022/spring6
username=root
password=root
initialSize=5
maxIdle=10
2、在xml文件中添加context命名空间以及约束文件
修改与util命名空间的修改时一样的
只不过把该util的地方该成context即可
3、准备好接收数据的几个属性
这里我创建了一个普通的类,用来接收数据
JDBC
private String driver;
private String url;
private String passwd;
private String initialSize;
private String maxIdle;
以及对应的set和toString方法
3、引入配置文件
<context:property-placeholder location="jdbc.properties"/>
<!--
注意这样写jdbc.properties 文件是放在resources类的根路径下的
-->
4、注入数据
<bean id="jdbcBean" class="com.nfjh.spring6.bean.JDBC" >
<property name="driver" value="${driverClassName}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="passwd" value="${password}"/>
<property name="initialSize" value="${initialSize}"/>
<property name="maxIdle" value="${maxIdle}"/>
</bean>
<!--
JDBC jdbcBean = applicationContext.getBean("jdbcBean", JDBC.class);
System.out.println(jdbcBean);
//JDBC{driver='com.mysql.jdbc.Driver', url='jdbc:mysql://localhost:2022/spring6', username='34838', passwd='root', initialSize='5', maxIdle='10'}
-->
${username}加载错误
需要注意的是Spring 的配置文件中有一个坑!!!
Spring 在加载配置文件的时候,会先加载系统的环境变量
此时如果jdbc.properties文件中存在username就会被加载为电脑的用户名
而不是我们的配置
解决的方式有三种
1、直接更换名字
把username换成 user_name 或者 name 或者其他的
但注意,spring在加载时不区分大小写,所以改成 userName是没用滴
还有当使用数据源时,存在无法更改配置文件中的名称,否则无法成功创
建连接的情况,此时建议使用其他的解决方案
2、添加配置信息local-override="true"
<context:property-placeholder local-override="true" location="jdbc.properties"/>
3、[已过时,但能用]使用另一个标签,并添加p命名空间
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" p:localOverride="true">
<property name="locations" value="classpath:jdbc.properties"></property>
</bean>
§5 Bean的作用域
public class ScopeBean {
public ScopeBean() {
System.out.println("无参构造执行了!");
}
}
@Test
public void testScopeBean(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean-scope.xml");
System.out.println("-------------");
ScopeBean scopeBean = applicationContext.getBean("scopeBean", ScopeBean.class);
System.out.println(scopeBean);
ScopeBean scopeBean2 = applicationContext.getBean("scopeBean", ScopeBean.class);
System.out.println(scopeBean2);
ScopeBean scopeBean3 = applicationContext.getBean("scopeBean", ScopeBean.class);
System.out.println(scopeBean3);
<!--spring默认bean的构建使用单例模式
单例模式对象给的创建在
new ClassPathXmlApplicationContext()的执行中
-->
<bean id="scopeBean" class="com.nfjh.spring6.bean.ScopeBean" scope="singleton"/>
<!--
/* 单例模式下:
无参构造执行了!
-------------
com.nfjh.spring6.bean.ScopeBean@75f95314
com.nfjh.spring6.bean.ScopeBean@75f95314
com.nfjh.spring6.bean.ScopeBean@75f95314
* */
-->
<!--可以更改为原型模式(每次获取的都是新的实例对象)
此时执行new ClassPathXmlApplicationContext()时不在创建对象
在执行 getBean()方法时创建对象
-->
<bean id="scopeBean" class="com.nfjh.spring6.bean.ScopeBean" scope="prototype"/>
<!--㊟:
prototype ['prәutәtaip]
n. 原型
[计] 样机; 原型
-->
<!--
/*
-------------
无参构造执行了!
com.nfjh.spring6.bean.ScopeBean@15dcfae7
无参构造执行了!
com.nfjh.spring6.bean.ScopeBean@3da05287
无参构造执行了!
com.nfjh.spring6.bean.ScopeBean@1e636ea3
*/
-->
§6 bean的获取方式
构造方法获取bean
简单工厂获取bean
public class Sweet {
public Sweet(){}
public void getType(){
System.out.println("这是一个水果糖");
}
}
public class SweetFactory {
//注意这个方法是静态的
public static Sweet get(){
return new Sweet();
}
}
<!--
1、简单工厂模式给"工厂类"注入
2、简单工厂模式的get方法是静态方法
使用1个bean 标签即可获取
Spring提供的实例化方式，第二种：通过简单工厂模式。你需要在Spring配置文件中告诉Spring框架，调用哪个类的哪个方法获取Bean
factory-method 属性指定的是工厂类当中的静态方法。也就是告诉Spring框架，调用这个方法可以获取Bean。
-->
<bean id="sweetFactory" class="com.nfjh.spring6.factory.SweetFactory" factory-method="get"/>
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("factory.xml");
Sweet sweet = applicationContext.getBean("sweetFactory", Sweet.class);
sweet.getType();
//这是一个水果糖
Factory-bean获取bean
Sweet还是使用上面的那个,原封不动
public class SweetFactor_Bean {
//此方法不在是静态的了
public Sweet get(){
return new Sweet();
}
}
<!--
factory-bean的方式获取对象
需要两个bean标签
Spring提供的实例化方式，第三种：通过工厂方法模式。通过 factory-bean属性 + factory-method属性来共同完成
告诉Spring框架，调用哪个对象的哪个方法来获取Bean。
-->
<bean id="sweetFactoryBean" class="com.nfjh.spring6.factory.SweetFactor_Bean"/>
<bean id="sweetBean" factory-bean="sweetFactoryBean" factory-method="get"/>
<!--
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("factory.xml");
Sweet sweetBean = applicationContext.getBean("sweetBean", Sweet.class);
sweetBean.getType();
//这是一个水果糖
-->
实现FactoryBean接口重写方法获取
/*
对于实现FactoryBean接口重写getObject()的方式
其实就是对第三中方式的简化
*/
还是Sweet不动
FactoryBeanImpl
import org.springframework.beans.factory.FactoryBean;
//该类实现了FactoryBean 所以不需要在配置factory-bean
public class FactroyBeanImpl implements FactoryBean<Sweet> {
//该类重写了getObject ,所以不在需要配置 factory-method
@Override
public Sweet getObject() throws Exception {
return new Sweet();
}
@Override
public Class<?> getObjectType() {
return null;
}
//返回的对象是否为单例对象,TRUE为单例,FALSE为多例
@Override
public boolean isSingleton() {
return FactoryBean.super.isSingleton();
}
}
<!--FactoryBeanImpl是一个工厂bean
是实现了FactoryBean接口的特殊bean
而辅助spring实例化其它Bean对象的特殊bean
-->
<bean id="sweetFactoryBeanImpl" class="com.nfjh.spring6.factory.FactroyBeanImpl"/>
<!--
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("factory.xml");
Sweet sweetBean = applicationContext.getBean("sweetFactoryBeanImpl", Sweet.class);
sweetBean.getType();
//这是一个水果糖
-->
Con
private Date date;
private String clientLog;
private String clientType;
以及对应的set和toSring方法
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFactoryBeanImpl implements FactoryBean<Date> {
private String strDate;
public DateFactoryBeanImpl(String strDate) {
this.strDate = strDate;
}
@Override
public Date getObject() throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
return sdf.parse(strDate);
}
@Override
public Class<?> getObjectType() {
return null;
}
}
<!--通过factoryBean的方式创建Date对象-->
<bean id="date" class="com.nfjh.spring6.factory.DateFactoryBeanImpl">
<constructor-arg value="2001-09-20"/>
</bean>
<bean id="conBean" class="com.nfjh.spring6.factory.Con">
<property name="date" ref="date"/>
<property name="clientType" value="QQ"/>
<property name="clientLog" value="QQ_Log"/>
</bean>
<!--
Con conBean = applicationContext.getBean("conBean", Con.class);
System.out.println(conBean);
//Condate=Thu Sep 20 00:00:00 CST 2001, clientLog='QQ_Log', clientType='QQ'}
-->
<!--
当然也可以使用其他方式对Con中的date进行注入
比如内部bean等
-->
<bean id="conBean2" class="com.nfjh.spring6.factory.Con">
<property name="date">
<bean class="com.nfjh.spring6.factory.DateFactoryBeanImpl">
<constructor-arg value="2001-09-20"/>
</bean>
</property>
<property name="clientType" value="WeChat"/>
<property name="clientLog" value="WeChat_Log"/>
</bean>
<!-- Con{date=Thu Sep 20 00:00:00 CST 2001, clientLog='WeChat_Log', clientType='WeChat'} -->
bean的生命周期
Student
public class Student {
private int age;
public Student() {
System.out.println("无参构造执行了!!!");
}
public void setAge(int age) {
System.out.println("赋值执行了");
this.age = age;
}
public void init(){
System.out.println("init初始化执行了!!!");
}
public void sleep(){
System.out.println("bean对象正在使用中!!!");
}
public void destroy(){
System.out.println("destroy方法执行了!!!");
}
}
@Test
public void testLifeCycle(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("lifecycle.xml");
Student student = applicationContext.getBean("lifecycleBean", Student.class);
student.sleep();
//销毁 [ApplicationContext没有close这个方法,需要向下转型]
ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
context.close(); //如果不加上这个关闭,destroy方法不会执行
}
5步
<bean id="lifecycleBean" class="com.nfjh.spring6.life_cycle.Student" init-method="init" destroy-method="destroy">
<property name="age" value="21"/>
</bean>
<!--
无参构造执行了!!!
赋值执行了
init初始化执行了!!!
bean对象正在使用中!!!
destroy方法执行了!!!
-->
7步
添加一个类实现BeanPostProcessor接口
重写其中的两个方法
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class LifeCycleAllBeanPost implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
//初始化之前执行
System.out.println("初始化之前执行");
return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
//初始化之后执行
System.out.println("初始化之后执行");
return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
}
}
<!--这个配置针对当前XML中所有的bean有效-->
<bean id="postProcessor" class="com.nfjh.spring6.life_cycle.LifeCycleAllBeanPost"/>
<bean id="lifecycleBean" class="com.nfjh.spring6.life_cycle.Student" init-method="init" destroy-method="destroy">
<property name="age" value="21"/>
</bean>
<!--对于相同的测试程序 7 步的结果为
无参构造执行了!!!
赋值执行了
初始化之前执行
init初始化执行了!!!
初始化之后执行
bean对象正在使用中!!!
-->
10步
5步
无参构造执行了
赋值执行了
initBean初始化执行了
bean对象正在使用中
destroyBean方法执行了
7步 在init的前后添加bean后处理器(BeanPostProcessor)
的postProcessBeforeInitialization
和postProcessAfterInitialization
10步是在
bean后处理器的Before方法前后添加
Aware的相关接口的检查,设置依赖
和InitializingBean接口的检查,调用接口方法
在使用bean之后添加
DisposableBean接口的检查,调用接口方法
Spring容器只对单例(singleton)的Bean进行完整的生命周期管理。
如果是prototype(多例)作用域的Bean，Spring容器只负责将该Bean初始化完毕。等客户端程序一旦获取到该Bean之后，Spring容器就不再管理该对象的生命周期了。
DefaultListableBeanFactory
@Test
public void registerBean(){
//让自己创建完毕的类纳入Spring容器的管理
Student student = new Student();
student.setAge(33);
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
factory.registerSingleton("studentBean",student);
Object studentBean = factory.getBean("studentBean");
System.out.println(student);
}
§7 IoC 注解式开发
Spring注解使用
- 第一步：加入aop的依赖
- 第二步：在配置文件中添加context命名空间
- 第三步：在配置文件中指定扫描的包
- 第四步：在Bean类上使用注解
声明Bean
@Component 声明所有类型 Bean
以下三个注解是@Component 注解的别名,可以使用@Component代替
但是代码的可读性会下降
@Controller 声明界面层的bean
@Service 声明业务逻辑层的bean
@Repository 声明数据访问层的bean
User.java
@Component(value="userBean")
如果注解的属性名是value，那么value是可以省略的@Component("userBean")
如果把value属性彻底去掉，spring会给Bean自动取名吗？会的。并且默认名字的规律是：Bean类名首字母小写即可@Component ==> getBean("user");
如果是多个包怎么办？有两种解决方案：
第一种：在配置文件中指定多个包，用逗号隔开
第二种：指定多个包的共同父包
我的疑问与测试
如果一个类中添加了注解,同时又在XML文件中进行了bean的配置
会不会报错,是两个都能用,还是两个都不能用
如果能用获得的对象是同一个吗[我只测试了单例模式下]
@Component
public class User {
}
<context:component-scan base-package="com.nfjh.bean"/>
<bean id="userBean" class="com.nfjh.bean.User"/>
@Test
@Test
public void testBean(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("Annotation-test.xml");
Object userBean = applicationContext.getBean("userBean");
Object userBean2 = applicationContext.getBean("user");
System.out.println(userBean);
System.out.println(userBean2);
}
/*
结果为两个都可以用,且获得的对象不是同一个
com.nfjh.bean.User@7756c3cd
com.nfjh.bean.User@2313052e
*/
指定注解类型生效[过滤]
<!--
先设置过滤所有 再确定只扫描的类型
context:component-scan[base-package & use-default-filters="false"] > context:include-filter[type expression]
先所有的都扫描,再设置不扫描的类型
context:component-scan[base-package & use-default-filters="true"] > context:exclude-filter [type expression]
base-package 需要扫描的包
use-default-filters
false表示全过滤 context:include-filter 需要添加的扫描
true表示全扫描 context:exclude-filter 需要过滤的类型 若为true use-default-filters="true" 可以不写
type annotation
expression
org.springframework.stereotype.Repository
org.springframework.stereotype.Service
org.springframework.stereotype.Controller
org.springframework.stereotype.Component
-->
注入数据
@Value
以前这样注入
<!--注入简单类型-->
<bean id="userBean" class="com.nfjh.spring6.bean.User">
<property name="username" value="zhangsan"/>
<property name="passwd" value="123"/>
<property name="age" value="20"/>
</bean>
使用注解这样注入
1、在属性上注入
@Component("userAnnotation")
public class User {
@Value("张三")
private String username;
@Value("123456")
private String passwd;
@Value("21")
private int age;
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", passwd='" + passwd + '\'' +
", age=" + age +
'}';
}
}
/*
㊟:使用@Value的注解方式,可以不用写构造方法和set以及get方法
toString方法只是用做输出看比较方便,也可以省略
User{username='张三', passwd='123456', age=21}
*/
2、在set方法上注入
@Component("userAnnotation")
public class User {
private String username;
private String passwd;
private int age;
@Value("张三")
public void setUsername(String username) {
this.username = username;
}
@Value("123456")
public void setPasswd(String passwd) {
this.passwd = passwd;
}
@Value("23")
public void setAge(int age) {
this.age = age;
}
/*
User{username='张三', passwd='123456', age=23}
*/
3、在构造方法的参数上进行注入
@Component("userAnnotation")
public class User {
private String username;
private String passwd;
private int age;
public User(@Value("李四") String username, @Value("3012") String passwd, @Value("23") int age) {
this.username = username;
this.passwd = passwd;
this.age = age;
}
/*
User{username='李四', passwd='3012', age=23}
*/
自动装配
@AutoWired 类型自动装配
AutoWired根据类型自动装配时,类型需要唯一
autowireTest
dao
UserDao
@Repository
public interface UserDao {
void insert();
}
impl
@Repository
public class UserDaoForJK implements UserDao{
@Override
public void insert() {
System.out.println("计科学生信息插入中");
}
}
service
UserService
@Service
public class UserService {
@Autowired
private UserDao userDao;
public void generate(){
userDao.insert();
}
}
<!--添加包扫描-->
<context:component-scan base-package="com.nfjh.autowireTest"/>
@Test
public void testAnnotationAutoWiredInjection(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("Annotation-test.xml");
Object userService = applicationContext.getBean("userService");
UserService service = (UserService) userService;
service.generate();
}
//计科学生信息插入中
缺点
如何解决同一接口有多个实现类,无法通过类型注入?
如果在impl包下添加实现类
@Repository
public class UserDaoForTX implements UserDao {
@Override
public void insert() {
System.out.println("通信学生信息插入中");
}
}
如果同一个类型有多个实现类,则Spring无法通过AutoWired直接进行装配
例如下面如果UserDao 的实现类除了UserDaoForJK之外还有一个userDaoForTX的话
在运行测试程序时会报错
org.springframework.beans.factory.UnsatisfiedDependencyException:
Error creating bean with name 'userService': Unsatisfied dependency expressed through field 'userDao'; nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.nfjh.autowireTest.dao.UserDao' available: expected single matching bean but found 2: userDaoForJK,userDaoForTX
注意:如果UserDao 有多页实现类,但是只有一个实现类添加了@Component以及他的别名,且
其他实现类也没有在XML文件中进行<bean>的配置
这种只算一个,也是可以正常装配的
@AutoWired + Qualifer名称自动装配
对与以上使用类型无法自动装载的问题,可以使用名称自动装载进行解决
在UserService中这样写
@AutoWired
@Qualifer("userDaoForTX")
private UserDao userDao;
注意@Qualifer括号中的内容是bean的id
即可指定UserService中装载的对象为userDaoForTX
@AutoWired出现的位置
以下举例以使用@AutoWired类型装配有多个实现类无法解决
为例,但是注意,当可以单独使用@AutoWired解决时,@AutoWired也是可以出现在这些位置上的
属性上,set方法上,构造方法上,构造方法的参数上,省略
1、属性上上面已经出现了,不再举例
2、set方法上
@Autowired
@Qualifier("userDaoForJK")
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
3、构造方法上
@Autowired
public UserService(UserDao userDao) {
this.userDao = userDao;
}
需要注意的是,@Qualifier限定符不适用于构造函数
" @Qualifier is not applicable for constructor"
所以在测试时,我把userDaoForJK类上的@Repository 给注释了
但是虽然@Qualifier无法在构造方法上使用,但是@Autowired可以
4、构造方法的参数上
public UserService(@Autowired @Qualifier("userDaoForJK") UserDao userDao) {
this.userDao = userDao;
}
5、不使用@Autowired
当且仅当有参数的构造方法只有一个,@Autowired注解可以省略
当然如果有多个构造方法,@Autowired不能省略,即使是无参的构造和有参构造,也不能省
public UserService(UserDao userDao) {
this.userDao = userDao;
}
[OS]最好不要省略,会降低代码的可读性!!
@Resource
使用使用这个注解是需要引入jar包的
Spring6支持的javaEE9 所以需要引入的是
<dependency>
<groupId>jakarta.annotation</groupId>
<artifactId>jakarta.annotation-api</artifactId>
<version>2.1.1</version>
</dependency>
dao
public interface StudentDao {
void delete();
}
impl
@Repository
public class StudentDaoImpl implements StudentDao {
@Override
public void delete() {
System.out.println("学生信息删除....");
}
}
service
@Service
public class StudentService {
@Resource(name="studentDaoImpl")
private StudentDao studentDaoProp;
public void delStu(){
studentDaoProp.delete();
}
1、@Resource 默认使用名称进行装配
当StudentDaoImpl的注解中value是空的
和上面使用@AutoWired结合@Qualifier一样名称默认是类名的首字母小写
@Resource(name="studentDaoImpl")
当value不为空时填写的
在使用@Resource时name="名称"
2、当名称为空时,属性名做为名称进行查找
impl
@Repository("studentDaoProp")
public class StudentDaoImpl implements StudentDao
service
@Resource
private StudentDao studentDaoProp;
3、当名称为空,且根据属性名无法查找到类时,根据类型进行查找
注意此时根据类型查找时,如果类型有多个,和@Autowired一样是不行的
impl
@Repository
public class StudentDaoImpl implements StudentDao
service
@Resource
private StudentDao studentDaoProp;
如果条件符合以上可以查询出结果
总结一下
| 注解类型 | 属性上 | set | 构造方法 | 构造方法的参数上 | 来源 |
|---|---|---|---|---|---|
| @Autowired | ✓ | ✓ | ✓ | ✓ | Spring |
| @Qualifier | ✓ | ✓ | × | ✓ | Spring |
| @Resource | ✓ | ✓ | × | × | JDK扩展包 |
同时,如果只是用@Autowired说明使用类型注入,被注入的类型是唯一的
@Autowired结合 @Qualifer 说明使用名称注入
全注解式开发
通过使用以上的注解,目前我们的配置文件中只有一个包扫描
<context:component-scan base-package="com.nfjh.bean"/>
现在编写一个类,用于代替这个配置文件
@Configuration
@ComponentScan({"com.nfjh.Resource.dao","com.nfjh.Resource.service"})
public class Spring6Config {
}
注意这里的注解 @Configuration 以及 @ComponentScan ,
看清楚不是@ComponentScans,不是s结尾！！！
注意此时已经没有了xml文件,所以这里的测试程序需要修改
使用"AnnotationConfigApplicationContext",传入“配置类”的类名,类名随意起,在这里传入即可
AnnotationConfigApplicationContext annotationConfigApplicationContext
= new AnnotationConfigApplicationContext(Spring6Config.class);
StudentService studentService = annotationConfigApplicationContext.getBean("studentService", StudentService.class);
studentService.delStu();
§8 jdbcTemplate
这部分看老杜的笔记
比较简单
AOP 面向切面编程
AOP七大术语
关于面向切面编程我的理解:
将与核心业务逻辑无关的代码进行抽离,形成以横向交叉应用于多个项目的"万金油"代码
例如事务管理,日志,安全等,提高代码的复用率
AOP面向切面编程是一种编程思想,而JDK动态代理和GBLIB动态代理就是AOP的实现
连接点[Joinpoint]
可以织入切面的位置
切点[Pointcut]
核心业务逻辑方法,真正织入切面的的方法
一个切点对应多个连接点
通知[Advice]
我们将要织入的增强代码
[前置通知、后置通知、环绕通知、异常通知、最终通知]
切面[Aspect]
切点 + 通知(在什么位置放什么代码)
织入 [Weaving]
把通知应用到目标对象上的过程。
代理对象[Proxy]
一个目标对象被织入通知后产生的新对象。
目标对象[Target]
被织入通知的对象。
切点表达式
execution([访问控制权限修饰符] 返回值类型 [全限定类名]方法名(形式参数列表) [异常])
AspectJ
1、使用Spring+AspectJ的AOP需要引入的依赖如下：
<!--spring context依赖-->
<!--spring aop依赖-->
<!--spring aspects依赖-->
2、Spring配置文件中添加context和aop的命名空间和约束文件
AspectJ框架__注解
5个通知类型
<!--组件扫描-->
<context:component-scan base-package="com.ndjh.spring6.service"/>
<!--交给spring管理,可用注解代替-->
<bean id="logAspect" class="com.ndjh.spring6.service.LogAspect"/>
<bean id="userService" class="com.ndjh.spring6.service.UserService"/>
<!-- 开启自动代理-->
<!-- proxy-target-class="true" 强制使用CGLIB动态代理
proxy-target-class="false" 默认值 ,依情况而定使用哪种代理
有接口使用JDK代理,其他使用CGLIB代理
-->
<aop:aspectj-autoproxy proxy-target-class="true"/>
service
UserService
//Target目标对象,待增强
public class UserService {
public void login(){
System.out.println("系统正在进行身份验证");
}
}
LogAspect
//@Aspect注解给spring检查
@Aspect
public class LogAspect {
//通知+切点
/*
通知就是增强代码
*/
//括号里是切点表达式
//execution([访问控制权限修饰符] 返回值类型 [全限定类名]方法名(形式参数列表) [异常])
//注意在全限定类名与方法名之间没有空格
//Before注解标注的是前置通知
@Before("execution(* com.ndjh.spring6.service..*(..))")
public void testBefore(){
System.out.println("前置通知");
}
@AfterReturning("execution(* com.ndjh.spring6.service..*(..))")
public void testAfterReturning(){
System.out.println("后置通知");
}
//注意环绕通知方法有参数,且有调用方法
@Around("execution(* com.ndjh.spring6.service..*(..))")
public void testAround(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("前环绕通知");
joinPoint.proceed();
System.out.println("后环绕通知");
}
//若异常环绕通知执行,则后环绕通知不会执行,而最终环绕通知执行
@AfterThrowing("execution(* com.ndjh.spring6.service..*(..))")
public void testAfterThrowing(){
System.out.println("异常通知");
}
@After("execution(* com.ndjh.spring6.service..*(..))")
public void testAfter(){
System.out.println("最终通知");
}
}
/*----在IDEDA2021.3中运行结果------
前环绕通知
前置通知
系统正在进行身份验证
后置通知
最终通知
后环绕通知
-------------------------------*/
现在修改代码UserService
增加异常
//Target目标对象,待增强
public class UserService {
public void login(){
System.out.println("系统正在进行身份验证");
throw new RuntimeException();
}
}
/*----在IDEDA2021.3中运行结果------
前环绕通知
前置通知
系统正在进行身份验证
异常通知
最终通知
java.lang.RuntimeException
at com.ndjh.spring6.service.UserService.login(UserService.java:8)
at com.ndjh.spring6.service.UserService$$FastClassBySpringCGLIB$$93098a3f.invoke(<generated>)
.........异常信息.............
观察可知,最终通知会执行,但是后环绕通知不在执行
-------------------------------*/
切面的顺序
对于“切面类”可以使用注解@Order进行排序
@Order(整型数字)
数字越小越先执行
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
@Documented
public @interface Order {
int value() default 2147483647;
}
通用切点表达式
@Pointcut("execution(* com.ndjh.spring6.service..*(..))")
public void generalExpression(){}
使用@Pointcut进行标注
当前类进行标注
@Before("generalExpression()")
public void testBefore(){
System.out.println("前置通知");
}
//跨类使用要写全限定类名+方法名()
@Before("com.ndjh.spring6.service.LogAspect.generalExpression()")
public void safetyBefore(){
System.out.println("安全前置通知");
}
AspectJ框架__XML
Spring事务
spring事务失效的12种场景：
访问权限问题
方法用final修饰
方法内部调用
末被spring管理
多线程调用
表不支持事务
未开启事务
错误的传播特性
自己吞了异常
手动抛了别的异常
自定义了回滚异常
嵌套事务回滚多了
spring集成Mybatis
pom文件
- 仓库地址
- spring-context
- spring-jdbc
- mybatis
- mybatis-spring
- jdbc
- druid
- junit
mapper : 接口
pojo : 普通类
service
接口
接口的实现类
归入Spring管理加上注解 @Service @Transactional
添加Mapper中的属性,加上注解 @Autowired,需要时再加上 @Qualifer
resources:
mapper
Mapper.xml 编写SQL语句
jdbc.properties
mybatis-config.xml
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
spring-config.xml
1、组件扫描
2、引入JDBC配置文件
3、数据源
4、sqlSessionFactoryBean配置
mybatis核心配置文件路径
数据源
指定别名 [sql中的resultType]
5、Mapper扫描mapper包
6、事务管理器
7、开启事务
<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://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/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<!--1、组件扫描-->
<context:component-scan base-package="com.nfjh.bank"/>
<!--2、引入JDBC属性文件-->
<context:property-placeholder location="jdbc.properties"/>
<!--3、数据源-->
<!--此处对应的Bean不用我们写,阿里巴巴写好了,我们直接用就行-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
<property name="url" value="${jdbc.url}"/>
<property name="driverClassName" value="${jdbc.driver}"/>
</bean>
<!--4、SqlSessionFactoryBean配置-->
<bean class="org.mybatis.spring.SqlSessionFactoryBean">
<!--注入mybatis核心配置文件路径-->
<property name="configLocation" value="mybatis-config.xml"/>
<!--数据源-->
<property name="dataSource" ref="dataSource"/>
<!--指定别名-->
<property name="typeAliasesPackage" value="com.nfjh.bank"/>
</bean>
<!--5、Mapper扫描mapper包,生成代理类-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.nfjh.bank.mapper"/>
</bean>
<!--6、事务管理器-->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!--开启事务-->
<tx:annotation-driven transaction-manager="txManager"/>
</beans>
浙公网安备 33010602011771号