Spring AOP可以动态地加载不同类，它可以在运行时动态地更改应用程序的行为。Spring AOP可以在运行时动态地更改应用程序的行为，而不需要重新编译它。Spring AOP可以在运行时动态地更改应用程序的行为，而不需要重新编译它。Spring AOP可以在运行时动态地更改应用程序的行为，而不需要重新编译它。Spring AOP可以在运行时动态地更改应用程序的行为，而不需要重新编译它。Spring AOP可以在运行时动态地更改应用程序的行为，而不需要重新编译它。
Spring AOP可以在运行时动态地更改应用程序的行为，而不需要重新编译它。它可以在运行时动态地更改应用程序的行为，从而提供更多的灵活性。它可以在运行时动态地更改应用程序的行为，从而提供更多的灵活性，可以更好地满足不同的业务需求。它还可以在运行时动态地更改应用程序的行为，从而提供更多的灵活性，可以更好地满足不同的业务需求，并且可以动态地加载不同类，从而更好地满足不同的业务需求。
1）连接点（Joinpoint）
程序执行的某个特定位置：如类开始初始化前、类初始化后、类某个方法调用前、调用后、方法抛出异常后。一个类或一段程序代码拥有一些具有边界性质的特定点，这些点中的特定点就称为“连接点”。Spring仅支持方法的连接点，即仅能在方法调用前、方法调用后、方法抛出异常时以及方法调用前后这些程序执行点织入增强。连接点由两个信息确定：第一是用方法表示的程序执行点；第二是用相对点表示的方位。
2）切点（Pointcut）
每个程序类都拥有多个连接点，如一个拥有两个方法的类，这两个方法都是连接点，即连接点是程序类中客观存在的事物。AOP通过“切点”定位特定的连接点。连接点相当于数据库中的记录，而切点相当于查询条件。切点和连接点不是一对一的关系，一个切点可以匹配多个连接点。在Spring中，切点通过orgspringframeworkaopPointcut接口进行描述，它使用类和方法作为连接点的查询条件，Spring AOP的规则解析引擎负责切点所设定的查询条件，找到对应的连接点。其实确切地说，不能称之为查询连接点，因为连接点是方法执行前、执行后等包括方位信息的具体程序执行点，而切点只定位到某个方法上，所以如果希望定位到具体连接点上，还需要提供方位信息。
3）增强（Advice）
增强是织入到目标类连接点上的一段程序代码，在Spring中，增强除用于描述一段程序代码外，还拥有另一个和连接点相关的信息，这便是执行点的方位。结合执行点方位信息和切点信息，我们就可以找到特定的连接点。
4）目标对象（Target）
增强逻辑的织入目标类。如果没有AOP，目标业务类需要自己实现所有逻辑，而在AOP的帮助下，目标业务类只实现那些非横切逻辑的程序逻辑，而性能监视和事务管理等这些横切逻辑则可以使用AOP动态织入到特定的连接点上。
5）引介（Introduction）
引介是一种特殊的增强，它为类添加一些属性和方法。这样，即使一个业务类原本没有实现某个接口，通过AOP的引介功能，我们可以动态地为该业务类添加接口的实现逻辑，让业务类成为这个接口的实现类。
6）织入（Weaving）
织入是将增强添加对目标类具体连接点上的过程。AOP像一台织布机，将目标类、增强或引介通过AOP这台织布机天衣无缝地编织到一起。根据不同的实现技术，AOP有三种织入的方式：
a、编译期织入，这要求使用特殊的Java编译器。
b、类装载期织入，这要求使用特殊的类装载器。
c、动态代理织入，在运行期为目标类添加增强生成子类的方式。
Spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。
7）代理（Proxy）
一个类被AOP织入增强后，就产出了一个结果类，它是融合了原类和增强逻辑的代理类。根据不同的代理方式，代理类既可能是和原类具有相同接口的类，也可能就是原类的子类，所以我们可以采用调用原类相同的方式调用代理类。
8）切面（Aspect）
切面由切点和增强（引介）组成，它既包括了横切逻辑的定义，也包括了连接点的定义，Spring AOP就是负责实施切面的框架，它将切面所定义的横切逻辑织入到切面所指定的连接点中。
之前自己用JDK动态代理实现过AOP功能，做得比较粗糙，仅供参考。
package cnseubingluoioc;
import javalangreflectInvocationHandler;
/
代理类
运用jdk动态代理实现，要求前提是被代理对象实现接口
/
public class ProxyHandler implements InvocationHandler {
// 存储所有切面
private static HashMap<String, AspectInfo> aspectInfos = new HashMap<String, AspectInfo>();
// 被代理的对象
private Object target = null;
public ProxyHandler(Object target) {
thistarget = target;
}
public static void addAspectInfo(AspectInfo aspectInfo) {
aspectInfosput(aspectInfogetExpression(), aspectInfo);
}
// 获取代理实例
public Object getProxyInstance() {
if (target == null) {
return null;
}
return ProxynewProxyInstance(targetgetClass()getClassLoader(),
targetgetClass()getInterfaces(), this);
}
// 获取代理实例
public Object getProxyInstance(Object target) {
if (target == null) {
return null;
}
thistarget = target;
return ProxynewProxyInstance(targetgetClass()getClassLoader(),
targetgetClass()getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
ArrayList<AspectInfo> aspects = new ArrayList<AspectInfo>();
Set<Entry<String, AspectInfo>> entrySet = aspectInfosentrySet();
Object result = null;
//遍历切面列表，找到对应的切面
for (Entry<String, AspectInfo> entry : entrySet) {
AspectInfo aspectInfo = entrygetValue();
Object adviceBean = aspectInfogetAdviceBean();
String expression = aspectInfogetExpression();
Pattern pattern = Patterncompile(expression);
Matcher matcher = patternmatcher(targetgetClass()getName() + ""
+ methodgetName());
if (matcherfind()) {
AspectInfo aspect = new AspectInfo();
aspectsetAdviceBean(adviceBean);
aspectsetBeforeMethod(aspectInfogetBeforeMethod());
aspectsetAroundMethod(aspectInfogetAroundMethod());
aspectsetAfterMethod(aspectInfogetAfterMethod());
aspectsadd(aspect);
}
}
// 执行before增强
for (AspectInfo aspect : aspects) {
Object adviceBean = aspectgetAdviceBean();
if (aspectgetBeforeMethod() != null) {
aspectgetBeforeMethod()invoke(adviceBean, new Object[]{});
}
}
// 执行around增强
Object aroundAdviceBean = target;
Method aroundAdviceMethod = method;
Object[] aroundAdviceArgs = args;
for (AspectInfo aspect : aspects) {
Object adviceBean = aspectgetAdviceBean();
if (aspectgetAroundMethod() != null) {
aroundAdviceArgs = new Object[] { new ProceedingJoinPoint(
aroundAdviceBean, aroundAdviceMethod, aroundAdviceArgs) };
aroundAdviceBean = adviceBean;
aroundAdviceMethod = aspectgetAroundMethod();
}
}
result = aroundAdviceMethodinvoke(aroundAdviceBean, aroundAdviceArgs);
// 执行After增强
for (AspectInfo aspect : aspects) {
Object adviceBean = aspectgetAdviceBean();
if (aspectgetAfterMethod() != null) {
aspectgetAfterMethod()invoke(adviceBean, new Object[]{});
}
}
return result;
}
}
ProceedingJoinPointjava
package cnseubingluoioc;
import javalangreflectInvocationTargetException;
/
用于处理AOP代理链时，封装相关信息作为统一参数进行传递
/
public class ProceedingJoinPoint {
private Object object;//被代理的对象
private Method method;//被代理的方法
private Object[] args;//方法相应的参数
public ProceedingJoinPoint(Object object, Method method, Object[] args){
thisobject = object;
thismethod = method;
thisargs = args;
}
//执行目标函数
public Object excute(){
Object result = null;
try {
result = methodinvoke(object, args);
} catch (IllegalArgumentException e) {
eprintStackTrace();
} catch (IllegalAccessException e) {
eprintStackTrace();
} catch (InvocationTargetException e) {
eprintStackTrace();
}
return result;
}
}
package cnseubingluoioc;
import javalangreflectMethod;
/
切面信息Bean
每1个切面最多只有：
1个切点expression
1个增强bean
1个前置增强、环绕增强、后置增强
/
public class AspectInfo {
private String expression = "";
private Object adviceBean = null;
private Method beforeMethod = null;
private Method aroundMethod = null;
private Method afterMethod = null;
public AspectInfo(){
}
public AspectInfo(String expression, Object adviceBean,
Method beforeMethod, Method aroundMethod, Method afterMethod) {
setExpression(expression);
setAdviceBean(adviceBean);
setBeforeMethod(beforeMethod);
setAroundMethod(aroundMethod);
setAfterMethod(afterMethod);
}
public String getExpression() {
return expression;
}
public void setExpression(String expression) {
thisexpression = expression;
}
public Object getAdviceBean() {
return adviceBean;
}
public void setAdviceBean(Object adviceBean) {
thisadviceBean = adviceBean;
}
public Method getBeforeMethod() {
return beforeMethod;
}
public void setBeforeMethod(Method beforeMethod) {
thisbeforeMethod = beforeMethod;
}
public Method getAroundMethod() {
return aroundMethod;
}
public void setAroundMethod(Method aroundMethod) {
thisaroundMethod = aroundMethod;
}
public Method getAfterMethod() {
return afterMethod;
}
public void setAfterMethod(Method afterMethod) {
thisafterMethod = afterMethod;
}
}
之前自己用JDK动态代理实现过AOP功能，做得比较粗糙，仅供参考。
package cnseubingluoioc;
import javalangreflectInvocationHandler;
/
代理类
运用jdk动态代理实现，要求前提是被代理对象实现接口
/
public class ProxyHandler implements InvocationHandler {
// 存储所有切面
private static HashMap<String, AspectInfo> aspectInfos = new HashMap<String, AspectInfo>();
// 被代理的对象
private Object target = null;
public ProxyHandler(Object target) {
thistarget = target;
}
public static void addAspectInfo(AspectInfo aspectInfo) {
aspectInfosput(aspectInfogetExpression(), aspectInfo);
}
// 获取代理实例
public Object getProxyInstance() {
if (target == null) {
return null;
}
return ProxynewProxyInstance(targetgetClass()getClassLoader(),
targetgetClass()getInterfaces(), this);
}
// 获取代理实例
public Object getProxyInstance(Object target) {
if (target == null) {
return null;
}
thistarget = target;
return ProxynewProxyInstance(targetgetClass()getClassLoader(),
targetgetClass()getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
ArrayList<AspectInfo> aspects = new ArrayList<AspectInfo>();
Set<Entry<String, AspectInfo>> entrySet = aspectInfosentrySet();
Object result = null;
//遍历切面列表，找到对应的切面
for (Entry<String, AspectInfo> entry : entrySet) {
AspectInfo aspectInfo = entrygetValue();
Object adviceBean = aspectInfogetAdviceBean();
String expression = aspectInfogetExpression();
Pattern pattern = Patterncompile(expression);
Matcher matcher = patternmatcher(targetgetClass()getName() + ""
+ methodgetName());
if (matcherfind()) {
AspectInfo aspect = new AspectInfo();
aspectsetAdviceBean(adviceBean);
aspectsetBeforeMethod(aspectInfogetBeforeMethod());
aspectsetAroundMethod(aspectInfogetAroundMethod());
aspectsetAfterMethod(aspectInfogetAfterMethod());
aspectsadd(aspect);
}
}
// 执行before增强
for (AspectInfo aspect : aspects) {
Object adviceBean = aspectgetAdviceBean();
if (aspectgetBeforeMethod() != null) {
aspectgetBeforeMethod()invoke(adviceBean, new Object[]{});
}
}
// 执行around增强
Object aroundAdviceBean = target;
Method aroundAdviceMethod = method;
Object[] aroundAdviceArgs = args;
for (AspectInfo aspect : aspects) {
Object adviceBean = aspectgetAdviceBean();
if (aspectgetAroundMethod() != null) {
aroundAdviceArgs = new Object[] { new ProceedingJoinPoint(
aroundAdviceBean, aroundAdviceMethod, aroundAdviceArgs) };
aroundAdviceBean = adviceBean;
aroundAdviceMethod = aspectgetAroundMethod();
}
}
result = aroundAdviceMethodinvoke(aroundAdviceBean, aroundAdviceArgs);
// 执行After增强
for (AspectInfo aspect : aspects) {
Object adviceBean = aspectgetAdviceBean();
if (aspectgetAfterMethod() != null) {
aspectgetAfterMethod()invoke(adviceBean, new Object[]{});
}
}
return result;
}
}
通过ProceedingJoinPoint可以得到当前被拦截的方法，具体是怎么样的我也记得不太清楚了，大概就是：pjpgetClass()getTarget()getMethod(pjpgetSignature()getName())然后可以得到Method对象，然后这个MethodgetReturnType即可
以上就是关于springaop动态加载不同类全部的内容，包括:springaop动态加载不同类、说说aop中的几个术语，它们是怎么相互工作的、AOP中的around的执行过程是怎样的等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）