Spring5 概述
下载的网址为:https://repo.spring.io/release/org/springframework/spring/ (下载之后压缩
libs内是jar包,导入spring包)
官方文档:https://www.docs4dev.com/docs/zh/spring-framework/5.1.3.RELEASE/reference/overview.html
- 轻量级开源的JAVAEE框架
- 可以解决企业复杂的应用
- 拥有IOC,AOP两个核心部分
Spring 入门案例
-
新建一个 java 项目
-
导入 Spring5 相关的 jar 包:
在project-setting->library
中添加 :
-
创建普通类以及普通方法
-
编写spring的配置文件
-
测试代码中读取配置的spring文件获得bean对象
public class testMethos { @Test public void testUser(){ //加载Spring配置文件 ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml"); //获取创建对象 User user = context.getBean("user",User.class); System.out.println(user); user.add(); } }
-
结果显示
IOC 容器-Bean管理
IOC 的定义
作用:
(1)控制反转,把对象创建和对象之间的调用过程,交给Spring进行管理
(2)使用IOC目的:为了耦合度降低
(3)做入门案例就是IOC实现
IOC的底层原理
第一步:XML解析 通过 xml 配置文件配置创建的对象
<bean id=" " class=" "></bean>
第二步:工厂模式 定义一个中间静态函数,降低其耦合度
第三步:反射 在工厂函数中通过反射创建对象。
Class xx=Class.forName(classValue);
xx.newInstance();
IOC 接口
IOC基于IOC容器,底层就是对象工厂
Spring 提供提供的 IOC 容器实现的两种方式:
- BeanFactory,IOC 容器实现的基本方式, Spring 内部使用接口,不提供给开发人员
加载配置xml解析不会创建,只有创建对象才会getBean ApplicationContext
是BeanFactory子接口,功能强大,开发人员可使用,
加载配置就会创建对象 ApplicationContext有一些特别的实现类:- 特别是ClassPathXmlApplicationContext,在src目录下可以写文件名
- 如果是FileSystemXmlApplicationContext,在src目录下,必须写绝对路径
在 idea 下
点击ctrl+H
可以进行查看
例如代码
//1 加载spring配置文件
ApplicationContext context =new ClassPathXmlApplicationContext("bean2.xml");
//2 获取配置创建的对象
UserService userService = context.getBean("userService", UserService.class);
IOC 操作 Bean 管理概述
Bean 管理主要包括两个方面:Spring 创建对象 和 Spring 注入属性
有两种方式可以实现:
- 基于xml配置方式实现
- 基于注解方式实现
IOC 操作 Bean 管理(基于XML)
一、 基于XML的方式创建对象
-
在spring配置文件中,使用 bean标签,在标签内加对应属性
<bean id="userService" class="com.atguigu.spring5.service.UserService">
其中 id属性 表示取一个别名; class属性表示 创建类中包的路径
-
在java文件中读取 Xml 并创建
//1 加载spring配置文件 ApplicationContext context =new ClassPathXmlApplicationContext("bean2.xml"); //2 获取配置创建的对象 UserService userService = context.getBean("userService", UserService.class);
创建完对象后,默认调用的是无参数构造函数完成对象创建
二、基于xml 方式的属性注入
-
第一种方式使用set方法进行注入,即用Spring 配置文件中的
poperty
属性完成属性注入/** * 演示使用set方法进行注入属性 */ public class Book { //创建属性 private String bname; private String bauthor; //创建属性对应的set方法 public void setBname(String bname) { this.bname = bname; } public void setBauthor(String bauthor) { this.bauthor = bauthor; } }
在spring配置文件配置对象创建,配置属性注入
-
第二种方式:使用参数构造进行注入
有参函数进行构造注入属性区别只是在xml以及java的方法构造而已,
首先创建有带属性构造函数的 bean 类
利用constructor-arg
属性来添加构造函数中的参数<bean id="orders" class="com.atguigu.spring5.Orders"> <constructor-arg name="oname" value="电脑"></constructor-arg> <constructor-arg name="address" value="China"></constructor-arg> </bean>
三、 P 名称空间注入(了解)
使用 p名称空间注入
,可以简化基于xml配置方式。主需要两步,如下:
第一步 添加p名称空间在配置文件中:
第二步 进行属性注入,在bean标签里面进行操作,直接属性赋值即可
<!--2 set方法注入属性-->
<bean id="book" class="com.atguigu.spring5.Book" p:bname="九阳神功" p:bauthor="无名氏"></bean>
四、 xml注入其他类型属性:字面量,外部bean,内部bean等
1、字面量
(1)null值
<!--null值-->
<property name="address"> <null/> </property>
(2)属性值包含特殊符号
<!--属性值包含特殊符号
1 把<>进行转义 < >
2 把带特殊符号内容写到CDATA -->
<property name="address"> <value><![CDATA[<<南京>>]]></value> </property>
2、注入属性-外部bean
(1)创建两个类 service类和dao类
(2)在service调用dao里面的方法
public class UserService {
//创建UserDao类型属性,生成set方法
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void add() {
System.out.println("service add...............");
userDao.update();
}
}
(3)在spring配置文件中进行配置
<!--1 service和dao对象创建-->
<bean id="userService" class="com.atguigu.spring5.service.UserService">
<!--注入userDao对象
name属性:类里面属性名称
ref属性:创建userDao对象bean标签id值
-->
<property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>
面向接口编程,只对变量进行声明所有的实现都在配置中
3. 注入属性-内部bean
一对多关系:部门和员工
- 一个部门有多个员工,一个员工属于一个部门(部门是一,员工是多)
部门类:
//部门类
public class Dept {
private String dname;
public void setDname(String dname) {
this.dname = dname;
}
}
员工类
对Spring 进行配置,结果如下:
注入属性-级联赋值
(1) 第一种写法
(2)第二种写法:使用对象调用,即先进行初始化,后调用set方法
配置如下:
<!--级联赋值-->
<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 注入集合属性
1、注入数组类型属性
2、注入List集合类型属性
3、注入Map集合类型属性
首先, 创建类,定义数组、list、map、set类型属性,生成对应set方法
然后在spring配置文件进行配置:
-
数组类型属性注入
<!--数组类型属性注入--> <property name="courses"> <array> <value>java课程</value> <value>数据库课程</value> </array> </property>
-
list 类型属性注入
<property name="list"> <list> <value>张三</value> <value>小三</value> </list> </property>
-
map 类型的属性注入
<property name="maps"> <map> <entry key="JAVA" value="java"> </entry> <entry key="PHP" value="php"></entry> </map> </property>
-
set类型属性注入
<!--set类型属性注入--> <property name="sets"> <set> <value>MySQL</value> <value>Redis</value> </set> </property>
在集合里面设置对象类型值
把集合注入部分提取出来
(1)在spring配置文件中引入名称空间 ·util
(2) 使用 util 标签完成 list 集合注入提取
<bean id="book" class="com.atguigu.spring5.collectiontype.Book">
<property name="list" ref="bookList"></property>
</bean>
六、Factory Bean
Spring有两种类型bean,一种普通bean,另外一种工厂bean(FactoryBean)
- 普通bean:在配置文件中定义bean类型就是返回类型
- 工厂bean:在配置文件定义bean类型可以和返回类型不一样
FactoryBean是一个接口,当在IOC容器中的Bean实现了FactoryBean接口
- 通过getBean(String BeanName)获取到的Bean对象并不是FactoryBean的实现类对象,
- 而是这个实现类中的getObject()方法返回的对象。要想获取FactoryBean的实现类,就要getBean(&BeanName),在BeanName之前加上&。
FactoryBean源码public interface FactoryBean<T> { T getObject() throws Exception; Class<?> getObjectType(); boolean isSingleton(); }
因此实现上面接口需要实现三个方法:
-
第一步 创建类,让这个类作为工厂bean,实现接口 FactoryBean
-
第二步 实现接口里面的方法,在实现的方法中定义返回的bean类型
配置文件如下:<bean id="myBean" class="com.atguigu.spring5.factorybean.MyBean"> </bean>
@Test public void test3() { ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml"); Course course = context.getBean("myBean", Course.class); System.out.println(course); }
BeanFactory和FactoryBean的区别
- BeanFactory是接口,提供了OC容器最基本的形式,给具体的IOC容器的实现提供了规范,
- FactoryBean也是接口,为IOC容器中Bean的实现提供了更加灵活的方式,FactoryBean 在IOC容器的基础上给Bean的实现加上了一个简单工厂模式和装饰模式, 我们可以在getObject()方法中灵活配置。其实在Spring源码中有很多FactoryBean的实现类.
七、Bean 作用域
- 在Spring里面,可以 设置创建bean实例是单实例还是多实例
- 在Spring里面,默认情况下,bean是单实例对象
例子如下:
- 通过 Spring 配置文件中的
scope
属性可以设置单实例还是多实例:
Scope 中共有两个属性:默认值 singleton 表示单实例对象; prototype 表示多实例对象
八、 Bean 的生命周期
生命周期: 从对象创建到对象销毁的过程,如下:
- 通过构造器创建bean实例(无参数构造)
- 为bean的属性设置值和对其他bean引用(调用set方法)
- 调用bean的初始化的方法(需要进行配置初始化的方法)
- bean可以使用了(对象获取到了)
- 当容器关闭时候,调用bean的销毁的方法(需要进行配置销毁的方法)
例子:
-
创建一个订单的bean,下面这方法都是自定义的。
public class Orders { //无参数构造 public Orders() { System.out.println("第一步 执行无参数构造创建bean实例"); } private String oname; public void setOname(String oname) { this.oname = oname; System.out.println("第二步 调用set方法设置属性值"); } //创建执行的初始化的方法 public void initMethod() { System.out.println("第三步 执行初始化的方法"); } //创建执行的销毁的方法 public void destroyMethod() { System.out.println("第五步 执行销毁的方法"); } }
-
编写spring 配置,将初始方法与销毁方法与bean中具体的方法进行绑定
<bean id="orders" class="com.atguigu.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod"> <property name="oname" value="手机"></property> </bean>
-
创建 bean文件,进行调用即可:
@Test public void testBean3() { // ApplicationContext context = // new ClassPathXmlApplicationContext("bean4.xml"); ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml"); Orders orders = context.getBean("orders", Orders.class); System.out.println("第四步 获取创建bean实例对象"); System.out.println(orders); //手动让bean实例销毁 context.close(); }
结果如下:
bean 的后置处理器,bean 生命周期有7步:
(1)通过构造器创建bean实例(无参数构造)
(2)为bean的属性设置值和对其他bean引用(调用set方法)
(3)把bean实例传递bean后置处理器的方法postProcessBeforeInitialization
(4)调用bean的初始化的方法(需要进行配置初始化的方法)
(5)把bean实例传递bean后置处理器的方法 postProcessAfterInitialization
(6)bean可以使用了(对象获取到了)
(7)当容器关闭时候,调用bean的销毁的方法(需要进行配置销毁的方法)
如上图所示,其实就是在原来的基础上添加了初始前与初始后函数,可以通过重新该函数为初始对象前后添加方法:
-
创建类,实现接口BeanPostProcessor,创建后置处理器
public class MyBeanPost implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("在初始化之前执行的方法"); return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println("在初始化之后执行的方法"); return bean; } }
-
配置后置处理器
<bean id="myBeanPost" class="com.avtguigu.spring5.bean.MyBeanPost"></bean>
如果将其写在外面,则表示该后置处理器属于全局的后置处理器
- 结果如下:
九、xml 自动装配
-
传统的xml配置 bean组件代码如下:
<bean id="userMapper" class="edu.cn.dao.UserMapperImpl"> <property name="sqlSessionFactory" ref="sqlSessionFactory"/> </bean> <bean id="userService" class="edu.cn.dao.UserServiceImpl"> <property name="userMapper" ref="userMapper"/> </bean>
我们通过标签为Bean的属性注入所需的值,当需要维护的 Bean 组件及需要注入的属性更多时,势必会增加配置的工作量。这时可以使用自动装配。
-
使用自动装配修改配置代码如下(也就是说 下面两个bean会根据自己属性的名字在xml配置中找到阈值相应的bean,直接进行匹配)
<bean id="userMapper" class="edu.cn.dao.UserMapperImpl" autowire="byName"/> <bean id="userService" class="edu.cn.dao.UserServiceImpl" autowire="byName"/>
定义: 根据指定装配规则(属性名称或者属性类型),Spring 自动将匹配的属性值进行注入
- 手动注入,为外部bean的实现过程,可参考如上过程
- 自动注入 实现自动装配
设置 bean 的autowire
标签即可进行自动装配,自动装配有两种:-
byName
根据属性名称注入 ,注入值bean的id值和类属性名称一样<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName"> <!--<property name="dept" ref="dept"></property>--> </bean> <bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
-
byType
根据属性类型注入<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType"> <!--<property name="dept" ref="dept"></property>--> </bean> <bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
-
byName 如果外部bean有多个bean的话,只需要有个配对上了就可以。但ByType如果外部有多个bean的话,会出错
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType"> <!--<property name="dept" ref="dept"></property>--> </bean> <bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean> <bean id="dept1" class="com.atguigu.spring5.autowire.Dept"></bean>
-
十、外部属性文件
-
通过配置数据库信息 和 配置德鲁伊连接池 引入德鲁伊连接池的jar包
具体引入过程是 先复制jar包到工程lib下,在project structure的module中点加号添加进入
-
配置数据连接池(两种方式)
- 直接配置
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"></property> <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property> <property name="username" value="root"></property> <property name="password" value="root"></property> </bean>
- 引入外部属性文件配置数据库连接池(而不是都放在xml文件,太多的name和value要修改)
在src下创建一个jdbc.properties的文件
把prop.driverClass=com.mysql.jdbc.Driver prop.url=jdbc:mysql://localhost:3306/userDb prop.userName=root prop.password=root
外部properties属性文件
引入到spring配置文件中:-
引入context名称空间
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
-
在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>
-
- 直接配置
IOC 操作 Bean 管理 (基于注解的方式)
定义
(1)注解是代码特殊标记,格式:@注解名称(属性名称=属性值, 属性名称=属性值…)
(2)使用注解,注解作用在类上面,方法上面,属性上面
(3)使用注解目的:简化xml配置
Spring针对Bean管理中创建对象提供注解
- @Component: 普通的注解
- @Service :业务逻辑层以及Service层
- @Controller: 外部层
- @Repository :dao层即持久层
上面四个注解功能是一样的,都可以用来创建bean实例*
基于注解方式实现对象创建
1. 引入依赖
2. 开启组件扫描
<!--开启组件扫描
1 如果扫描多个包,多个包使用逗号隔开
2 扫描包上层目录
-->
<context:component-scan base-package="com.atguigu"></context:component-scan>
3. 创建类,在类上面添加创建对象注解
//在注解里面value属性值可以省略不写,
//默认值是类名称,首字母小写
//UserService -- userService
@Component(value = "userService") //<bean id="userService" class=".."/>
public class UserService {
public void add() {
System.out.println("service add.......");
}
}
4. 开启组件扫描细节配置
-
设置扫描的注解类
<!--示例 1 use-default-filters="false" 表示现在不使用默认 filter,自己配置 filter context:include-filter ,设置扫描哪些内容 type只扫描这种注解类 --> <context:component-scan base-package="com.atguigu" use-defaultfilters="false"> <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/><!--代表只扫描Controller注解的类--> </context:component-scan>
-
设置不扫描的注解类
<!--示例 2 下面配置扫描包所有内容 context:exclude-filter: 设置哪些内容不进行扫描 --> <context:component-scan base-package="com.atguigu"> <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/><!--表示Controller注解的类之外一切都进行扫描--> </context:component-scan>
基于注解方式实现属性注入
基于注解方式实现属性注入
- @AutoWired:根据属性类型自动装配
- @Qualifier:根据属性名称自动注入
- @Resource:可根据属性类型或者名称注入
- @Value:注入普通类型的注
@Autowired:根据属性类型进行自动装配
第一步 把 service 和 dao 对象创建,在 service 和 dao 类添加创建对象注解
第二步 在service注入dao对象,在service类添加dao类型属性,在属性上面使用注解
public class UserService {
//定义dao类型属性
//不需要添加set方法
//添加注入属性注解
@Autowired
private UserDao userDao;
public void add() {
System.out.println("service add.......");
userDao.add();
}
}
@Qualifier:根据名称进行注入
这个 @Qualifier
注解的使用,和上面 @Autowired
一起使用
//定义dao类型属性
//不需要添加set方法
//添加注入属性注解
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;
如果仅仅使用 Autowired 那么就是根据类型装配,如果加了 Qualifier
那么就是根据名称注入
@Resource:可以根据类型注入,可以根据名称注入
//@Resource
//根据类型进行注入
@Resource(name = "userDaoImpl1")
//根据名称进行注入
private UserDao userDao;
@Value:注入普通类型属性
@Value(value = "abc")
private String name;
完全注解开发
-
(1)创建配置类,替代xml配置文件
@Configuration //作为配置类,替代xml配置文件 @ComponentScan(basePackages = {"com.atguigu"}) public class SpringConfig { }
-
(2) 测试类的编写
@Test public void testService2() { //加载配置类 ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class); UserService userService = context.getBean("userService", UserService.class); System.out.println(userService); userService.add(); }
AOP 的定义
- 面向切面编程(方面),利用 AOP 可以对业务逻辑的各个部分进行隔离,从而使得 业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
- 通俗描述:不通过修改源代码方式,在主干功能里面添加新功能
- 使用登录例子说明 AOP,如下图:
AOP 实现的底层原理
AOP 底层使用动态代理 ,动态代理有两种情况:
- 第一种:有接口情况,使用 JDK 动态代理 ;创建接口实现类代理对象,增强类的方法
- 第二种:没有接口情况,使用 CGLIB 动态代理;创建子类的代理对象,增强类的方法
AOP(JDK动态代理)
详情可见
https://blog.csdn.net/Mr_tianyanxiaobai/article/details/118857976
使用 JDK 动态代理,需要使用 Proxy 类里面的方法 newProxyInstance
创建代理对象
调用 newProxyInstance 方法
,方法有三个参数:
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
- 第一参数,类加载器
- 第二参数,增强方法所在的类,这个类实现的接口,支持多个接口
- 第三参数,实现这个接口
InvocationHandler
,创建代理对象,写增强的部分
编写 JDK 动态代理代码:
-
(1)创建接口,定义方法
//(1)创建接口,定义方法 public interface UserDao { public int add(int a,int b); public String update(String id); }
-
(2) 创建接口实现类,实现方法
//(1)创建接口,定义方法 public interface UserDao { public int add(int a,int b); public String update(String id); }
-
(3)创建代理对象代码
//创建代理对象代码 class UserDaoProxy implements InvocationHandler { //1 把创建的是谁的代理对象,把谁传递过来 //有参数构造传递 private Object obj; public UserDaoProxy(Object obj) { this.obj = obj; } //增强的逻辑 @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //方法之前 System.out.println("方法之前执行...."+method.getName()+" :传递的参数..."+ Arrays.toString(args)); //被增强的方法执行 Object res = method.invoke(obj, args); //方法之后 System.out.println("方法之后执行...."+obj); return res; } }
-
(4) 使用代理类创建对象进行测试:
//(3)使用 Proxy 类创建接口代理对象 public class JDKProxy { public static void main(String[] args) { //创建接口实现类代理对象 Class[] interfaces = {UserDao.class}; UserDaoImpl userDao = new UserDaoImpl(); /** 第一参数,类加载器 第二参数,增强方法所在的类,这个类实现的接口,(支持多个接口) 第三参数,实现这个接口 InvocationHandler,创建代理对象,写增强的部分 */ UserDao dao =(UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao)); int result = dao.add(1, 2); System.out.println("result:"+result); } }
AOP(术语)
- a)连接点:类里面哪些方法可以被增强,这些方法称为连接
- b)切入点:实际被真正增强的方法称为切入点
- c)通知(增强):实际增强的逻辑部分称为通知,且分为以下五种类型:
- 1)前置通知
- 2)后置通知
- 3)环绕通知
- 4)异常通知
- 5)最终通知
- d)切面:把通知应用到切入点过程
AOP 操作
Spring 框架一般都是基于 AspectJ 实现 AOP 操作
- AspectJ 不是 Spring 组成部分,独立 AOP 框架,一般把 AspectJ 和 Spirng 框架一起使 用,进行 AOP 操作
基于 AspectJ 实现 AOP 操作:
1)基于 xml 配置文件实现
2)基于注解方式实现(使用)
在项目中我们需要引入下面的相关依赖:
切入点表达式
切入点表达式作用:知道对哪个类里面的哪个方法进行增强
语法结构:
@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.*.* (..))
AOP 操作(AspectJ 注解)
-
创建类,在类里面定义方法
public class User { public void add() { System.out.println("add......."); } }
-
创建增强类(编写增强逻辑),注意此时增强类无需包含原类的函数逻辑
//(1)在增强类里面,创建方法,让不同方法代表不同通知类型 //增强的类 public class UserProxy { public void before() {//前置通知 System.out.println("before......"); } }
-
进行通知的配置
在Spring 配置文件中,开启注解扫描<!--3、进行通知的配置--> <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 开启注解扫描 --> <context:component-scan base-package="com.atguigu.spring5.aopanno"></context:component-scan> <!-- 开启Aspect生成代理对象--> <aop:aspectj-autoproxy></aop:aspectj-autoproxy> </beans>
使用注解创建User和UserProxy对象(在上面的原类和增强类上面都增加注解)
//增强的类 @Component @Aspect //生成代理对象 public class UserProxy {} //被增强的类 @Component public class User {}
在增强类上添加注解
@Aspect
//增强的类 @Component @Aspect //生成代理对象 public class UserProxy {
在spring配置文件中开启生成代理对象
<!-- 开启Aspect生成代理对象--> <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
-
配置不同类型的通知
在增强类的里面,在作为通知方法上面添加通知类型注解。
使用切入点表达式进行配置//4、配置不同类型的通知 @Component @Aspect //生成代理对象 public class UserProxy { //相同切入点抽取,相当于是add的另外一个名字,改名字在代理对象中的方法叫做 pointdemo @Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))") public void pointdemo() { } //前置通知 //@Before注解表示作为前置通知 @Before(value = "pointdemo()")//相同切入点抽取使用!这里可以使用别名 // 也可以使用 add 的真正路径 //@Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))") public void before() { System.out.println("before........."); } //后置通知(返回通知) @AfterReturning(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))") public void afterReturning() { System.out.println("afterReturning........."); } //最终通知 @After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))") public void after() { System.out.println("after........."); } //异常通知 @AfterThrowing(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))") public void afterThrowing() { System.out.println("afterThrowing........."); } //环绕通知 @Around(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))") public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { System.out.println("环绕之前........."); //被增强的方法执行 proceedingJoinPoint.proceed(); System.out.println("环绕之后........."); } }
-
有多个增强类对同一个方法进行增强,设置增强类优先级
在增强类上面添加注解@Order(数字类型值)
,数字类型值越小优先级越高@Component @Aspect @Order(1) public class Proxy1{ } @Component @Aspect @Order(3) public class Proxy2{ }
-
完全使用注解开发
创建配置类,不需要创建xml配置文件@Configuration @ComponentScan(basePackages = {"com.atguigu"}) @EnableAspectJAutoProxy(proxyTargetClass = true) public class ConfigAop { }
AOP 操作(AspectJ 配置文件)
1、创建两个类,增强类和被增强类,创建方法
2、在spring配置文件中创建两个类对象
<!--创建对象-->
<bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>
3、在 spring 配置文件中配置切入点
<!--3、在 spring 配置文件中配置切入点-->
<!--配置 aop 增强-->
<aop:config>
<!--切入点-->
<aop:pointcut id="p" expression="execution(* com.atguigu.spring5.aopxml.Book.buy(..))"/>
<!--配置切面-->
<aop:aspect ref="bookProxy">
<!--增强作用在具体的方法上-->
<aop:before method="before" pointcut-ref="p"/>
</aop:aspect>
</aop:config>