Spring笔记汇总
1.1 问题
在JavaEE分层开发开发中,那个层次对于我们来讲最重要
DAO ---> Service --> Controller
JavaEE分层开发中, 最为重要的是Service层
Service层中包含了哪些代码?
Service层中 = 核心功能(几十行上百代码) +额外功能(附加功能)
1.核心功能
2.额外功能
(如:事务、日志、性能…)
事务:如增删改时提交事务,查询时不用
日志:记录(谁 + 时间 + 什么事 + 结果)【记录用户重要操作的"流水账"】
性能:开发阶段可能监控性能,但是发布阶段可能性能优化得特别好了,就不用进行监控性能的操作了
额外功能书写在Service层中好不好?
Service层的调用者的角度 (Controller) :
通过代理类,为原始类(目标)增加额外的功能
好处:利于原始类(目标)的维护
a. 目标类 原始类
b. 目标方法,原始方法
c. 额外功能(附加功能)
代理类=目标类(原始类) +额外功能+原始类(目标类)实现相同的接口
房东---> public interface UserService{
m1
m2
}
UserServiceImpl implements UserService{
m1 ---> 业务运算DAO调用
m2
}
UserServiceProxy implements UserService{
m1
m2
}
静态代理:为每一个原始类,手工编写一 个代理类 (.java .class)
静态类文件数量过多,不利于项目管理
额外功能维护性差
代理类中额外功能修改复杂(麻烦)
概念:通过代理类为原始类(目标类)增加额外功能
好处:利于原始类(目标类)的维护
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-aopartifactId>
<version>5.2.5.RELEASEversion>
dependency>
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjrtartifactId>
<version>1.9.5version>
dependency>
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjweaverartifactId>
<version>1.9.5version>
dependency>
public class UserServiceImpl implements UserService {
@Override
public void register(User user) {
System.out.println("UserServiceImpl.register 业务运算 + Dao");
}
@Override
public boolean login(String name, String password) {
System.out.println("UserServiceImpl.login");
return true;
}
}
<bean id="userService" class="com.company.proxy.UserServiceImpl"/>
额外的功能书写在接口的实现中,运行在原始方法执行之前运行额外功能。
public class Before implements MethodBeforeAdvice {
/*
作用:需要把运行在原始方法执行之前运行的额外功能,书写在before方法中
*/
@Override
public void before(Method method, Object[] objects, Object o) throws Throwable {
System.out.println("-----method before advice log-----");
}
}
<bean id="before" class="com.company.dynamic.Before"/>
简单的测试:所有方法都做为切入点,都加入额外的功能。
<aop:config>
<aop:pointcut id="pc" expression="execution(* *(..))"/>
aop:config>
<aop:config>
<aop:pointcut id="pc" expression="execution(* *(..))"/>
<aop:advisor advice-ref="before" pointcut-ref="pc"/>
aop:config>
目的:获得Spring工厂创建的动态代理对象,并进行调用
ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
注意:
1.Spring的工厂通过原始对象的id值获得的是代理对象
2.获得代理对象后,可以通过声明接口类型,进行对象的存储
UserService userService=(UserService)ctx.getBean("userService");
userService.login(" ")
userService.register()
1、Spring创建的动态代理类在哪里?
Spring框架在运行时,通过动态字节码技术,在JVM创建的,运行在JVM内部,等程序结束后,会和JVM一起消失
什么叫动态字节码技术?
通过第三个动态字节码框架,在JVM中创建对应类的字节码,进而创建对象,当虚拟机结束,动态字节码跟着消失。
结论:动态代理不需要定义类文件,都是JVM运行过程中动态创建的,所以不会造成静态代理,类文件数量过多,影响项目管理的问题。
2、动态代理 编程简化代理的开发
在额外功能不改变的前提下, 创建其他目标类(原始类)的代理对象时,只需要指定原始(目标)对象即可。
3、动态代理额外功能的维护性大大增强
关闭修改,增加扩展
<bean id="before" class="com.company.dynamic.Before1"/>
1. MethodBeforeAdvice接口作用:额外功能运行在原始方法执行之前,进行额外功能操作。
public class Before implements MethodBeforeAdvice {
/*
作用:需要把运行在原始方法执行之前运行的额外功能,书写在before方法中
Method:额外功能所增加给的那个原始方法
login方法
register方法
showOrder方法
Object[]:额外功能所增加给的那个原始方法的参数。
login方法 ---> String name, String password
register方法 ---> User
Object:额外功能所增加给的那个原始对象
UserServiceImpl
OrderServiceImpl
*/
@Override
public void before(Method method, Object[] objects, Object o) throws Throwable {
System.out.println("-----method before advice log-----");
}
}
2.before方法的3个参数在实战中,该如何使用。
before方法的参数,在实战中,会根据需要进行使用,不一定都会用到,也有可能都不用。
methodinterceptor接口:额外功能可以根据需要运行在原始方法执行前、后、前后。
public class Arround implements MethodInterceptor {
/*
invoke方法的作用:额外功能书写在invoke
额外功能 原始方法之前
原始方法之后
原始方法执行之前 之后
确定:原始方法怎么运行
参数: MethodInvocation (Method) :额外功能所增加给的那个原始方法
login
register
invocation. proceed() ---> login运行
register运行
返回值: Object: 原始方法的返回值
*/
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
System.out.println("--- 前 额外功能 log ---");
Object ret = methodInvocation.proceed();
System.out.println("--- 后 额外功能 log ---");
return ret;
}
}
有什么样的额外功能运行在原始方法执行之前,之后都要添加?事务
额外功能运行在原始方法抛出异常的时候
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
Object ret = null;
try {
ret = methodInvocation.proceed();
} catch (Throwable throwable) {
System.out.println("原始方法抛出异常 执行的额外功能");
throwable.printStackTrace();
}
return ret;
}
MethodInterceptor影响原始方法的返回值
原始方法的返回值,直接作为invoke方法的返回值返回, MethodInterceptor不会影响原始方法的返回值
MethodInterceptor影响原始方法的返回值
Invoke方法的返回值,不要直接返回原始方法的运行结果即可。
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
Object ret = null;
ret = methodInvocation.proceed();
// 此时返回为false
return false;
}
切入点决定额外功能加入位置(方法)
<aop :pointcut id="pc" expression="execution(* *(..))"/>
exection(* *(..)) ---> 匹配了所有方法 a b c
1.execution() 切入点函数
2.* *(..) 切入点表达式
* *(..) --> 所有方法
* --->修饰符返回值
* --->方法名
() ---> 参数表
.. ---> 对于参数没有要求(参数有没有,参数有几个都行,参数是什么类型的都行)
定义login方法作为切入点
* login(..)
定义register作为切入点
* register(..)
定义login方法且login方法有两个字符串类型的参数作为切入点
* login(String,String)
注意:非java.lang包中的类型,必须写全类名
* register(com.company.proxy.User)
..可以与具体的参数类型连用
* login(String,..) --> login(String),login(String,String),login(String,com.company.proxy.User)
精准方法切入点限定
修饰符 返回值 包.类.方法(参数)
* com.company.proxy.UserServiceImpl.login(..)
* com.company.proxy.UserServiceImpl.login(String, String)
指定特定类作为切入点(额外功能加入的位置),自然这个类中的所有方法,都会加上对应的额外功能。
类中的所有方法加入了额外功能
* com.company.proxy.UserSerivceImpl.*(..)
忽略包
1. 类只存在一级包 com.UserServiceImpl
* *.UserServiceImpl.*(..)
2. 类存在多级包 com.company.proxy.UserServiceImpl
* *..UserServiceImpl.*(..)
指定包作为额外功能加入的位置,自然包中的所有类及其方法都会加入额外的功能
运用时可以将需要额外功能的放一个包,不用额外功能的放另外一个包
切入点包中的所有类,必须在proxy中, 不能在proxy包的子包中
* com.company.proxy.*.*(..)
切入点当前包及其子包都生效
* com.company.proxy..*.*(..)
切入点函数:用于执行切入点表达式
最为重要的切入点函数,功能最全。
执行方法切入点表达式类切入点表达式包切入点表达式
弊端: execution执行切入点表达式,书写麻烦
execution(* com.company.proxy..*.*(..))
注意:其他的切入点函数简化是execution书写复杂度,功能上完全一致
作用:主要用于函数(方法)参数的匹配
切入点:方法参数必须得是2个字符串类型的参数
execution(* *(String, String))
args(String, String)
作用:主要用于进行类、包切入点表达式的匹配
切入点: UserServiceImpl这个类
execution(* *..UserServiceImpl.*(..))
within( *..UserServiceImpl)
execution(* com.company.proxy..*.*(..))
within( com.company.proxy..*)
作用:为具有特殊注解的方法加入额外功能
// 自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
}
@Log
public void register(User user) {}
// 添加额外功能
<aop:pointcut id="pc" expression="@annotation(com.company.Log)"/>
指的是整合多个切入点函数一起配合工作,进而完成更为复杂的需求
案例: login同时 参数 2个字符串
1. execution(* login(String, String))
2. execution(* login(..)) and args(String, String)
注意:与操作不能用于同种类型的切入点函数
案例: register方法和login方法作为切入点
// execution(* login(..)) and execution(* register(..)) ---> 此时代表的是方法名既是login又是register的方法
execution(* login(..)) or execution(* register(..))
案例: register方法和login方法作为切入点
execution(* login(..)) or execution(* register(..))
Spring学习笔记:详解AOP编程