1. Spring
1. 前言
-
Spring : 春天 —>给软件行业带来了春天
-
2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。
-
2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。
-
很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
-
Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术
2. 初衷
-
JAVA EE开发应该更加简单。
-
使用接口而不是使用类，是更好的编程习惯。Spring将使用接口的复杂度几乎降低到了零。
-
为JavaBean提供了一个更好的应用配置框架。
-
更多地强调面向对象的设计，而不是现行的技术如JAVA EE。
-
尽量减少不必要的异常捕捉。
-
使应用程序更加容易测试。
3. 基本组成
- 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
- Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
- Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中。
- Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
- Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
- Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
- Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。
2. IOC
1. IOC本质
控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法。
没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制。控制反转后将对象的创建转移给第三方，以XML或注解并通过第三方去生产或获取特定对象的方式
Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。
简单来说：需要对象不用自己手动去创建，Spring帮你来创建，管理，装配。当需要修改时，只需要修改xml中标签的属性值，不用去修改代码。
2. spring程序
导入Jar包
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.10.RELEASE</version>
</dependency>
实体类Hello
public class Hello {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("Hello,"+ name );
}
}
spring 文件 beans.xml
其中bean标签中的id值相当于对象名，class的值表示要new的类，property标签表示给对象中的属性property设置一个值value。
如果property的值的类型是一个对象，可以使用ref,表示引用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
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--bean就是java对象 , 由Spring创建和管理-->
<bean id="hello" class="com.pojo.Hello">
<property name="name" value="Spring"/>
</bean>
</beans>
测试类
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");这句话表示拿到spring容器，然后用context.getBean("id")来获取对象，而不用去new了
@Test
public void test(){
//解析beans.xml文件 , 生成管理相应的Bean对象
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//getBean : 参数即为spring配置文件中bean的id .
Hello hello = (Hello) context.getBean("hello");
hello.show();
}
3. 控制反转
Hello 对象是谁创建的 ? hello 对象是由Spring创建的
Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的
这个过程就叫控制反转 :
- 控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
- 反转 : 程序本身不创建对象 , 而变成被动的接收对象 .
依赖注入 : 就是利用set方法来进行注入的
4. IOC创建对象方式
- 默认使用无参构造方法创建对象
- 当使用有参构造时，有三种方法
在配置文件加载的时候，容器中管理的对象就已经初始化了
通过无参构造方法来创建
User.java
public class User {
private String name;
public User() {
System.out.println("user无参构造方法");
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("name="+ name );
}
}
beans.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="user" class="com.pojo.User">
<property name="name" value="张师傅"/>
</bean>
</beans>
测试类
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//在执行getBean的时候, user已经创建好了 , 通过无参构造
User user = (User) context.getBean("user");
//调用对象的方法 .
user.show();
}
通过有参构造方法来创建
UserT . java
public class UserT {
private String name;
public UserT(String name) {
this.name = name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("name="+ name );
}
}
beans.xml 有三种方式编写 (下标、参数名、参数类型)
<!-- 第一种根据index参数下标设置 -->
<bean id="userT" class="com.pojo.UserT">
<!-- index指构造方法 , 下标从0开始 -->
<constructor-arg index="0" value="kuangshen2"/>
</bean>
<!-- 第二种根据参数名字设置 -->
<bean id="userT" class="com.pojo.UserT">
<!-- name指参数名 -->
<constructor-arg name="name" value="kuangshen2"/>
</bean>
<!-- 第三种根据参数类型设置 -->
<bean id="userT" class="com.pojo.UserT">
<constructor-arg type="java.lang.String" value="kuangshen2"/>
</bean>
测试
@Test
public void testT(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
UserT user = (UserT) context.getBean("userT");
user.show();
}
5. 依赖注入
依赖：bean对象的创建依赖于容器！
注入：bean对象中的所有属性，由容器来注入！
构造器注入
- 默认使用无参构造方法创建对象
- 当使用有参构造时，有三种方法
Set 注入
实体类Student
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbys;
private Map<String,String> card;
private Set<String> games;
private String wife;
private Properties info;
public void setName(String name) {
this.name = name;
}
public void setAddress(Address address) {
this.address = address;
}
public void setBooks(String[] books) {
this.books = books;
}
public void setHobbys(List<String> hobbys) {
this.hobbys = hobbys;
}
public void setCard(Map<String, String> card) {
this.card = card;
}
public void setGames(Set<String> games) {
this.games = games;
}
public void setWife(String wife) {
this.wife = wife;
}
public void setInfo(Properties info) {
this.info = info;
}
public void show(){
System.out.println("name="+ name
+ ",address="+ address.getAddress()
+ ",books="
);
for (String book:books){
System.out.print("<<"+book+">>\t");
}
System.out.println("\n爱好:"+hobbys);
System.out.println("card:"+card);
System.out.println("games:"+games);
System.out.println("wife:"+wife);
System.out.println("info:"+info);
}
}
beans.xml
//注册Address实体类
<bean id="addr" class="com.pojo.Address">
<property name="address" value="重庆"/>
</bean>
//注册Student实体类
<bean id="student" class="com.pojo.Student">
<property name="name" value="Lewis"/>//普通值，用value
<property name="address" ref="addr"/>//对象，用ref，与上面的地址bean的id值相同
<property name="books"> //数组注入
<array>
<value>红楼梦</value>
<value>西游记</value>
<value>三国演义</value>
</array>
</property>
<property name="hobbies"> //List注入
<list>
<value>听歌</value>
<value>敲代码</value>
<value>看电影</value>
</list>
</property>
<property name="card"> //Map注入
<map>
<entry key="身份证" value="4306XXXXXXXX"/>
<entry key="银行卡" value="1903XXXXXXXX"/>
</map>
</property>
<property name="games"> //Set注入
<set>
<value>LOL</value>
<value>DNF</value>
<value>CS</value>
</set>
</property>
//null注入
<property name="wife">
<null/>
</property>
<property name="info"> //properties资源文件注入
<props>
<prop key="url">jdbc:mysql://localhost:3306</prop>
<prop key="name">root</prop>
<prop key="password">123456</prop>
</props>
</property>
</bean>
p命名和c命名注入
- P命名空间注入 : 需要在头文件中加入约束文件
导入约束 : xmlns:p="http://www.springframework.org/schema/p"
<!--P(属性: properties)命名空间 , 属性依然要设置set方法-->
<bean id="user" class="com.pojo.User" p:name="狂神" p:age="18"/>
- c 命名空间注入 : 需要在头文件中加入约束文件
导入约束 : xmlns:c="http://www.springframework.org/schema/c"
<!--C(构造: Constructor)命名空间 , 属性依然要设置set方法-->
<bean id="user" class="com.pojo.User" c:name="狂神" c:age="18"/>
c 就是所谓的构造器注入！
3. Bean
1. Bean的作用域
- 单例模式：
Spring默认机制，一个类只实例化一次，通过get方法得到的对象，即使对象的名字不同，本质还是同一个 - 原型模式：
每次从容器中get时，都会产生一个新对象！适用于多线程 - 其余的
request，session，application，只能在web开发中使用到，表示对象的生存周期
2. 自动装配
- 自动装配是使用spring满足bean依赖的一种方法。spring会在应用上下文中为某个bean寻找其依赖的bean。
自动装配的操作
- 组件扫描(component scanning)：spring会自动发现应用上下文中所创建的bean；
- 自动装配(autowiring)：spring自动满足bean之间的依赖，也就是我们说的IoC/DI；
代码
public class Cat {
public void shout() {
System.out.println("miao~");
}
}
class Dog {
public void shout() {
System.out.println("wang~");
}
}
//实体类People，有两个宠物Cat,Dog
class People{
private String name;
private Cat cat; //猫，狗的实体类省略，知道是一个对象类型就行
private Dog dog;
public setCat(Cat cat){
this.cat=cat;
}
public getCat(){
return this.cat;
}
public setDog(Dog dog){
this.dog=dog;
}
public getDog(){
return this.dog;
}
}
<bean id="cat" class="pojo/Cat"/>
<bean id="dog" class="pojo/Dog"/>
<bean id="people" class="pojo/People" autowire="byName">
<property name="name" value="Lewis"/>
//<property name="cat" ref="cat"/>自动装配会自动完成，这两行代码可以省略
//<property name="dog" ref="dog"/>
</bean>
autowire byName (按名称自动装配)
- 会自动在容器上下文中查找和
people对象set方法后面的值对应的bean的id。如People实体类中有一个setDog方法，且beans.xml文件中有一个id值为dog的bean，因此people bean中可以省略dog的property，会自动注入。 - 实体类有
setDog方法，beans.xml中有id="dog"的bean，省略`dog property - 需要保证所有bean的id唯一，并且这个id要和自动注入的属性的set方法的值一致！
autowire byType (按类型自动装配)
-
自动在容器中查找和自己对象类型相同的bean（同一个pojo中）。
-
需要保证所有的bean的class唯一，并且这个bean的属性要和自动注入的属性类型一致！
3. 别名
alias 设置别名 , 为bean设置别名 , 可以设置多个别名
<!--设置别名：在获取Bean的时候可以使用别名获取-->
<alias name="userT" alias="userNew"/>
Bean的配置
<!--bean就是java对象,由Spring创建和管理-->
<!--
id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
如果配置id,又配置了name,那么name是别名
name可以设置多个别名,可以用逗号,分号,空格隔开
如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;
class是bean的全限定名=包名+类名
-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.pojo.Hello">
<property name="name" value="Spring"/>
</bean>
4. import
团队的合作通过import来实现 .
<import resource="{path}/beans.xml"/>
4. 注解开发
1、在spring配置文件中引入context文件头
xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
2、开启属性注解支持！
<context:annotation-config/>
1. 自动装配
-
@Autowired：先通过类型byType，再通过名字byName，用在对象属性上
//如果允许对象为null，设置required = false,默认为true @Autowired(required = false) private Cat cat; -
@Qualifier :可以根据byName的方式自动装配,不能单独使用。
@Autowired @Qualifier(value = "cat2") private Cat cat; @Autowired @Qualifier(value = "dog2") private Dog dog; -
@resource：先通过名字byName，再通过类型byType，用在对象属性上
//如果允许对象为null，设置required = false,默认为true @Resource(name = "cat2") private Cat cat; @Resource private Dog dog;
2. Bean的实现
1、配置扫描哪些包下的注解
<!--指定注解扫描包-->
<context:component-scan base-package="com.kuang.pojo"/>
-
@Component：对整个类进行装配。衍生出@Respository，@Service，@Controller，分别用在Dao层Service层、Controller层的类上，效果一样。所有属性不用写get/set方法
-
@Value：用在属性上，给属性赋值
@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
@Value("秦疆")
// 相当于配置文件中 <property name="name" value="秦疆"/>
public String name;
}
- @scope：作用域
- singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂 ，所有的对象都会销毁。
- prototype：多例模式。关闭工厂 ，所有的对象不会销毁。内部的垃圾回收机制会回收
@Controller("user")
@Scope("prototype")
public class User {
public String name;
}
3. 小结：
- XML更加万能，适用于任何场合，维护简单方便！
- 注解不是自己的类使用不了，维护相对复杂
- xml用来管理bean，注解只完成属性的注入。
5. JavaConfig
使用一个JavaConfig类，来替代原来的beans.xml
1、编写一个实体类，Dog
@Component //将这个类标注为Spring的一个组件，放到容器中！
public class User {
public String name='张三';
}
2、新建一个config配置包，编写一个MyConfig配置类
@Configuration //代表这是一个配置类
@ComponentScan("pojo")
//这个类也会被注入到Spring容器中，其本质就是一个@Component
//@Configuration代表这是一个配置类，用于替代beans.xml
public class MyConfig {
@Bean
//注册一个bean，相当于xml里的一个bean标签
//方法的名字相当于bean标签的id值
//方法的返回类型相当于bean标签的class属性值
public User getUser(){
return new User();
}
}
3、测试
@Test
public void test2(){
ApplicationContext applicationContext =
new AnnotationConfigApplicationContext(MyConfig.class);
User user = (User) applicationContext.getBean("user");
System.out.println(user.name);
}
注解：
- @Configuration //代表这是一个配置类
- @Import(MyConfig2.class) //导入合并其他配置类，类似于配置文件中的 inculde 标签
- @ComponentScan(“pojo”) //自动扫描包下的文件
- @Bean //通过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id！
6. 静态代理
1. 角色分析
- 抽象角色 : 一般使用接口或者抽象类来实现
- 真实角色 : 被代理的角色
- 代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作 .
- 客户 : 使用代理角色来进行一些操作 .
2. 代码实现
Rent. java 即抽象角色 租房
//抽象角色：租房
public interface Rent {
public void rent();
}
Host . java 即真实角色 房东
//真实角色: 房东，房东要出租房子
public class Host implements Rent{
public void rent() {
System.out.println("房屋出租");
}
}
Proxy . java 即代理角色 中介
//代理角色：中介
public class Proxy implements Rent {
private Host host;
public Proxy() { }
public Proxy(Host host) {
this.host = host;
}
//租房
public void rent(){
seeHouse();
host.rent();
fare();
}
//看房
public void seeHouse(){
System.out.println("带房客看房");
}
//收中介费
public void fare(){
System.out.println("收中介费");
}
}
Client . java 即客户
//客户类，一般客户都会去找代理！
public class Client {
public static void main(String[] args) {
//房东要租房
Host host = new Host();
//中介帮助房东
Proxy proxy = new Proxy(host);
//你去找中介！
proxy.rent();
}
}
分析：在这个过程中，你直接接触的就是中介，就如同现实生活中的样子，你看不到房东，但是你依旧租到了房东的房子通过代理，这就是所谓的代理模式。
3. 优缺点
优点 :
- 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
- 公共的业务由代理来完成 . 实现了业务的分工 ,
- 公共业务发生扩展时变得更加集中和方便 .
缺点 :
- 类多了 , 多了代理类 , 工作量变大了 . 开发效率降低 .
7. 静态代理
-
动态代理的角色和静态代理的一样 .
-
动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的
-
动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理
-
- 基于接口的动态代理----JDK动态代理
- 基于类的动态代理–cglib
JDK的动态代理需要了解两个类
核心 : InvocationHandler调用处理程序 和 Proxy代理
1. InvocationHandler
InvocationHandler接口是proxy代理实例的调用处理程序实现的一个接口，每一个proxy代理实例都有一个关联的调用处理程序；在代理实例调用方法时，方法调用被编码分派到调用处理程序的invoke方法。
/**
* proxy:代理类代理的真实代理对象com.sun.proxy.$Proxy0
* method:我们所要调用某个对象真实的方法的Method对象
* args:指代代理对象方法传递的参数
*/
Object invoke(Object proxy, 方法 method, Object[] args)；
2. Proxy
Proxy类就是用来创建一个代理对象的类，它提供了很多方法，但是我们最常用的是newProxyInstance方法。
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h);
- loader：一个classloader对象，定义了由哪个classloader对象对生成的代理类进行加载
- interfaces：一个interface对象数组，表示我们将要给我们的代理对象提供一组什么样的接口，如果我们提供了这样一个接口对象数组，那么也就是声明了代理类实现了这些接口，代理类就可以调用接口中声明的所有方法。
- h：一个InvocationHandler对象，表示的是当动态代理对象调用方法的时候会关联到哪一个InvocationHandler对象上，并最终由其调用。
3. 代码
Rent . java 即抽象角色
//抽象角色：租房
public interface Rent {
public void rent();
}
Host . java 即真实角色
//真实角色: 房东，房东要出租房子
public class Host implements Rent{
public void rent() {
System.out.println("房屋出租");
}
}
ProxyInvocationHandler. java 即代理角色
public class ProxyInvocationHandler implements InvocationHandler {
private Object target;
public void setTarget(Object target) {
this.target = target;
}
//生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
}
// proxy : 代理类 method : 代理类的调用处理程序的方法对象.
// 处理代理实例上的方法调用并返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
seeHouse();
//核心：本质利用反射实现！
Object result = method.invoke(target, args);
fare();
return result;
}
//看房
public void seeHouse(){
System.out.println("带房客看房");
}
//收中介费
public void fare(){
System.out.println("收中介费");
}
}
Client . java
//租客
public class Client {
public static void main(String[] args) {
//真实角色
Host host = new Host();
//代理实例的调用处理程序
ProxyInvocationHandler pih = new ProxyInvocationHandler();
pih.setRent(host); //将真实角色放置进去！
Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
proxy.rent();
}
}
4. 好处
静态代理有的它都有，静态代理没有的，它也有！
- 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
- 公共的业务由代理来完成 . 实现了业务的分工 ,
- 公共业务发生扩展时变得更加集中和方便 .
- 一个动态代理 , 一般代理某一类业务
- 一个动态代理可以代理多个类，代理的是接口！
8. AOP
1. 什么是AOP
AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
2. Aop在Spring中的作用
提供声明式事务；允许用户自定义切面
- 横切关注点：横跨多个模块的方法或功能，待加入到业务层实现功能扩充，如日志功能
- 切面（aspect）：横切关注点被模块化的特殊对象，是一个类，即下文中的
afterLog类 - 通知（advice）：切面必须完成的工作，即
afterLog类中的一个方法 - 目标（target）：被通知对象，下文中的
UserServiceImpl类的对象 - 代理（proxy）：向目标对象加入通知创建的新对象
- 切入点（pointcut）：切面通知执行的“地点”的定义
- 连接点（jointpoint）：与切入点匹配的执行点
3. 5种连接点位置增强
| 通知类型 | 连接点 | 结构 | 注解 |
|---|---|---|---|
| 前置通知 | 方法前 | org.springframework.aop.BeforeAdvice | Before |
| 后置通知 | 方法后 | org.springframework.aop.AfterReturningAdvice | AfterReturning |
| 环绕通知 | 方法前后 | org.aopalliance.intercept.MethodInterceptor | Around |
| 异常通知 | 方法抛出异常 | org.springframework.aop.ThrowsAdvice | AfterThrowing |
| 引介通知 | 类中增加新的方法 | org.springframework.aop.IntroductionInterceptor | After |
4. Spring API接口实现
public interface UserService {
public void add();
public void delete();
public void update();
public void select();
}
//UserServiceImpl实现类
public class UserServiceImpl implements UserService{
public void add() {
System.out.println("增加了一个用户");
}
public void delete() {
System.out.println("删除了一个用户");
}
public void update() {
System.out.println("修改了一个用户");
}
public void select() {
System.out.println("查询了一个用户");
}
}
//afterLog
public class afterLog implements AfterReturningAdvice {
public void afterReturning(Object returnValue, Method method, Object[] objects, Object o1) throws Throwable {
System.out.println("执行了"+method.getName()+"方法，返回的结果为"+returnValue);
}
}
//beforeLog
public class beforeLog implements MethodBeforeAdvice {
public void before(Method method, Object[] objects, Object target) throws Throwable {
System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
}
}
<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
">
<!-- 注册bean-->
<bean id="userService" class="com.service.UserServiceImpl"/>
<bean id="afterLog" class="com.log.afterLog"/>
<bean id="beforeLog" class="com.log.beforeLog"/>
<aop:config>
<aop:pointcut id="pointcup" expression="execution(* service.UserServiceImpl.*(..))"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcup"/>
<aop:advisor advice-ref="beforeLog" pointcut-ref="pointcup"/>
</aop:config>
</beans>
5. 自定义实现AOP
public class DiyPointCut {
public void before(){
System.out.println("===========方法执行前================");
}
public void after(){
System.out.println("===========方法执行后================");
}
}
<bean id="diy" class="diy.DiyPointCut"/>
<aop:config>
<!--切面：一个类-->
<aop:aspect ref="diy">
<!--切入点-->
<aop:pointcut id="point" expression="execution(* service.UserServiceImpl.*(..))"/>
<!--通知-->
<aop:after method="after" pointcut-ref="point"/>
<aop:before method="before" pointcut-ref="point"/>
</aop:aspect>
</aop:config>
6. 使用注解实现AOP
<bean id="annotationPointCut" class="diy.AnnotationPointCut"/>
<!--开启注解支持-->
<aop:aspectj-autoproxy/>
@Aspect
public class AnnotationPointCut {
@Before("execution(* service.UserServiceImpl.*(..))")
public void before(){
System.out.println("===========方法执行前===========");
}
@After("execution(* service.UserServiceImpl.*(..))")
public void after(){
System.out.println("===========方法执行后===========");
}
@Around("execution(* service.UserServiceImpl.*(..))")
public void around(){
System.out.println("===========环绕后===========");
}
}
视频教程[狂神说B站]:https://www.bilibili.com/video/BV1WE411d7Dv
扫一扫
4870
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
