动态代理与注解(Spring IOC、AOP核心)

最新推荐文章于 2024-06-29 13:23:46 发布
最新推荐文章于 2024-06-29 13:23:46 发布
阅读量1.3k 收藏 5
点赞数 3
分类专栏： java 设计模式 文章标签： 动态代理 注解 Java注解 Annotation
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25956141/article/details/89640020
版权

介绍

Spring两大核心，IOC和AOP，其中AOP用到了动态代理，常用于日志记录，性能统计，安全控制，事物处理，异常处理等，主要将与业务无关的逻辑从代码中抽离出来复用，实现解耦。
动态代理是在静态代理的基础上产生的，博主之前介绍过静态代理模式。静态代理模式对弊端是被代理对象需要实现其公共接口以及接口的所有方法。试想若在一个系统中要给所有对象的所有方法都加上日志记录，让所有代理对象都去实现其接口是不妥的，不能体现其复用性，耦合度也较高。
动态代理通过反射技术，在调用被代理的对象的方法时，动态增加一些操作。

核心操作

动态代理通过Proxy类创建代理对象，需要被代理对象有接口的实现。

//CLassLoader loader:类的加载器
//Class<?> interfaces:得到全部的接口
//InvocationHandler h:得到InvocationHandler接口的子类的实例
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

我们通过Proxy的newProxyInstance(…)方法创建代理对象，其有三个参数，前两个参数是易懂的，InvocationHandler用来对被代理对象的原方法进行拦截，给被代理对象增加逻辑的，如日志记录。

//Object proxy:被代理的对象
//Method method:要调用的方法
//Object[] args:方法调用时所需要参数
public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

动态代理通过InvocationHandler给被代理对象增加逻辑，其进一步通过InvocationHandler的invoke方法给代理对象增加逻辑，之后通过调用method.invoke(真实被代理对象，方法参数)来调用被代理对象的逻辑。

示例

一个常见的需求是给业务方法增加日志，这里通过动态代理，以简单的输出到控制器为例。
业务接口：

package test;
public interface UserManager {	//业务接口
	public void addUser();
}

接口实现：

package test;
public class UserManagerImpl implements UserManager{
	@Override
	public void addUser() {
		System.out.println("A user added");
	}
}

创建代理的工厂：

package test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyFactory {
	public static Object createLogProxy(final Object arg){
		Object obj = Proxy.newProxyInstance(arg.getClass().getClassLoader(), arg.getClass().getInterfaces(), new InvocationHandler() {
			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				System.out.println("start method->>" + method.getName());		//增加日志记录
				method.invoke(arg, args);
				System.out.println("end method->>" + method.getName());		//增肌日志记录
				return proxy;
			}
		});
		return obj;
	}
}

客户端使用代理对象：

package test;
import org.junit.Test;

public class ProxyTest {
	@Test
	public void test(){
		UserManager manager = (UserManager) ProxyFactory.createLogProxy(new UserManagerImpl());
		manager.addUser();
	}
}

输出结果：

start->>addUser
A user added
end->>addUser

注解

一种常见的场景就是动态代理和注解结合。注解在Spring中被应用的淋漓尽致，我们可以通过注解实现IOC,AOP，其大大提高了程序的开发效率，简化了开发流程。注解技术是面向框架级开发的，一般在往常的业务开发中较少使用注解来添加配置信息。在Spring中，AOP的实现可以用配置文件加动态代理实现，亦可以使用注解加动态代理实现，事实上，注解充当的就是一种配置的作用。
接下来将介绍Java中常见的几种元注解，以及如何自定义注解，如何获取注解中信息等。

JDK的元注解

所谓的元注解即给自定义注解使用的注解，一般表示你定义的注解用在什么地方，作用范围是什么。
JDK提供的几种元注解有@Retention、@Target、@Document、@Inherited。
另外必须指出的一点是：注解都是通过(属性名=值)的方式进行定义，若属性名为value，可以在定义时省略。如下的@Retention就省略了“value=”。

  • @Retention Retention注解有如下几种，一般情况下，我们定义的注解都是RUNTIME，即给运行的程序使用。 
  • 	@Retention(RetentionPolicy.SOURCE):	在.java文件中有效，给编译器使用
	@Retention(RetentionPolicy.class):在class文件中有效，给类加载器使用
	@Retention(RetentionPolicy.RUNTIME):给运行程序使用
  • Target Target注解表示你所定义的注解的目标是什么，其有如下三种。 
  • @Target(value={ElementType.METHOD,ElementType.TYPE,ElementType.FILED})

    我们发现，其使用了一个数组进行定义，表示你定义的注解可以使用在方法、类/接口/enum、属性。

  • Documented 使用了该注解定义的注解，注解信息会生成到文档。
  • Inherited 应用了该注解的注解，会被自动继承到子类。如你希望你某个接口下的所有实现类都使用你定义的注解，那么无需在每个实现类中都去增加，你只需在其接口类中使用该注解即可轻易派生到其子类或实现类。
  • 自定义注解

    以上介绍了JDK的元注解，即给自定义注解使用的注解。如何自定义一个注解？如下所示：

    @Retention(RetentionPolicy.RUNTIME)	//表示该注解在程序运行时生效
@Target({ElementType.METHOD})		//表示该注解应用在方法上
public @interface PersonInfo{
	String name();
	int age();
	int id() default 0;
}

    如何应用注解？所加的注解并不能直接生效，需要通过反射的方法解析注解。
    接下来以Spring IOC中给属性添加，自动给属性赋值为例。
    一种常见的场景是，DAO的配置，在DAO层通常有多个DAO的实现类，如MysqlDao，SqlserverDao等。给配置了注解的属性动态赋值，其需要通过解析该属性，并获取注解，之后拿到注解中所配置的类信息，最后生成实例将其写入到属性中。
    1、定义注解：

    import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface DBInfo {
	String value();
}

    2、在类的属性上应用注解
    UserDao接口

    public interface UserDao {
	public void save();	//为了简单起见省略参数
	public void get();
}

    UserDaoImpl实现类

    public class UserMysqlDao implements UserDao {
	@Override
	public void save() {
		System.out.println("A user saved to mysql...");
	}

	@Override
	public void get() {
		System.out.println("Got a user from mysql...");
	}
}

    public class UserSqlserverDao implements UserDao{
	@Override
	public void save() {
		System.out.println("A user saved to sqlserver...");
	}

	@Override
	public void get() {
		System.out.println("Got a user from sqlserver...");
	}
}

    添加注解

    public class UserService {
	@DBInfo("UserMysqlDao")
	private UserDao userDao;
	public void addUser(){
		userDao.save();
	}
	
	public void getUser(){
		userDao.get();
	}
}

    3、解析注解，赋予属性

    import java.lang.reflect.Field;
public class Main {
	public static void main(String[] args) throws Exception {
		UserService service = createUserService();
		service.addUser();
	}
	
	//在Spring框架，这个部分交给Spring容器管理，为了简单起见，这里使用一个静态方法
	public static UserService createUserService() throws Exception{
		UserService service = new UserService();
		Class<?> clazz = service.getClass();
		
		Field[] fields = clazz.getDeclaredFields();
		for (Field field : fields) {
			if(field.isAnnotationPresent(DBInfo.class)){	//先判断是否含有该注解
				DBInfo dbAnnotation = field.getAnnotation(DBInfo.class);	//获取该注解
				String dbClassStr = dbAnnotation.value();	//获取注解里的信息
				Class<?> dbClass = Class.forName(dbClassStr);	//生成目标实例对象
				Object obj = dbClass.newInstance();				//通过反射创建示例对象
				field.setAccessible(true);	//设置属性可以被访问
				field.set(service, obj);	//对该属性赋值
			}
		}
		return service;
	}
}

    在上述注解的解析流程中，无需关心DBInfo中的配置是什么，也无需关心属性名是什么，而只需关心把含有DBInfo配置的属性都动态赋值成注解中所配置的类的示例对象。
    输出结果：
    A user saved to mysql…

    动态代理结合注解

    在Sprong AOP中，开发人员使用一个注解就能对其进行事物处理或者权限控制。其原理为通过使用动态代理和注解进行结合。
    接下来以权限控制为例。
    在上面的例子中，我们希望给Dao增加权限控制。对save方法判断当前用户是否具有该权限，权限的读取应该去数据库中检查，为了简单起见，这里直接定义了一个数组表示该用户具有的权限。

    增加自定义注解

    修改UserDao接口

    import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Inherited
public @interface PrivilegeInfo {
	String value();
}

    给需要检查权限的方法添加注解

    public interface UserDao {
	@PrivilegeInfo("save")
	public void save();	//为了简单起见省略参数
	public void get();
}

    结合动态代理解析注解

    import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyFactory {
	public static Object createPrivilegeProxy(final Object arg){
		Object obj = Proxy.newProxyInstance(arg.getClass().getClassLoader(), arg.getClass().getInterfaces(), new InvocationHandler() {
			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				if(method.isAnnotationPresent(PrivilegeInfo.class)){
					//权限校验
					//原本应该去数据库中判断当前用户的权限，这里简单起见就定义一个数组
					String privileges[] = {"save","get"};	//这些权限来自于数据库
					for (String privilege : privileges) {
						if(privilege.equals(method.getAnnotation(PrivilegeInfo.class).value())){
							method.invoke(arg, args);
							System.out.println("拥有权限");
						}
					}
				}else{	//没有配置注解，直接放行
					method.invoke(arg, args);
				}
				return proxy;
			}
		});
		return obj;
	}
}

    在初始化对象时

    import java.lang.reflect.Field;

public class Main {
	public static void main(String[] args) throws Exception {
		UserService service = createUserService();
		service.addUser();
	}
	
	//在Spring框架，这个部分交给Spring容器管理，为了简单起见，这里使用一个静态方法
	public static UserService createUserService() throws Exception{
		UserService service = new UserService();
		Class<?> clazz = service.getClass();
		
		Field[] fields = clazz.getDeclaredFields();
		for (Field field : fields) {
			if(field.isAnnotationPresent(DBInfo.class)){
				DBInfo dbAnnotation = field.getAnnotation(DBInfo.class);
				String dbClassStr = dbAnnotation.value();
				Class<?> dbClass = Class.forName(dbClassStr);
				Object obj = dbClass.newInstance();
				field.setAccessible(true);	//设置属性可以被访问
				field.set(service, ProxyFactory.createPrivilegeProxy(obj));	//设置成代理对象
			}
		}
		return service;
	}
}

    输出结果：
    A user saved to mysql…
    拥有权限

    总结

    代理模式注重对原方法的拦截，增加新的逻辑，是权限校验还是日志记录还是事物处理，根据实际需求进行定义。在本节中，讨论了动态代理的优点，以及如何编写一个动态代理类来处理日志。又讨论了注解的使用方法，动态代理与注解技术相结合的例子。

    参考文献

    https://blog.csdn.net/qq_25956141/article/details/83692730
    https://blog.csdn.net/hejingyuan6/article/details/36203505#

丶丶路遥
关注
专栏目录
“掌握Spring IoC和AOP：30道面试必备问题解析！“
weixin_44976692的博客
01-03 2万+
在面试过程中，Spring的IoC（控制反转）和AOP（面向切面编程）是被频繁问及的重要主题。掌握这两个核心概念和技术，对于成为一名优秀的Java开发者至关重要。本篇博客将为你提供一份包含20个关键问题的面试指南，助你在面试中游刃有余，展现出对Spring IoC和AOP的深刻理解。无论你是初学者还是有经验的开发者，这20个问题将覆盖IoC和AOP的核心知识点，帮你更好地准备面试。让我们一同深入探讨，揭秘Spring的IoC和AOP的奥秘，为你的面试之路加分不少！🚀💻。
Android进阶必学：自定义注解之动态代理
风花散却隽世间，雪月寥落化雨田
03-09 1206
自定义注解是Android进阶的必学知识，从现在起我讲为大家带来四篇文章，让大家彻底学会自定义注解 静态代理大家都明白，就是相当于包装了一次，在包装这一次的时候可以加一些业务逻辑。同样静态代理的特点是一个接口对应一个代理类，当然委托类可以多个。 静态代理 /** * 定义Demo接口 */ public interface Demo { public ...
Java_注解、动态代理
qq_48083892的博客
01-18 936
注解和反射一样，都是用来做框架的，我们这里学习注解的目的其实是为了以后学习框架或者做框架做铺垫的。那注解该怎么学呢？和反射的学习套路一样，我们先充分的认识注解，掌握注解的定义和使用格式，然后再学习它的应用场景。先来认识一下什么是注解？Java注解是代码中的特殊标记，比如@Override、@Test等，作用是：让其他程序根据注解信息决定怎么执行该程序。比如：Junit框架的@Test注解可以用在方法上，用来标记这个方法是测试方法，被@Test标记的方法能够被Junit框架执行。
Spring动态代理详解
最新发布
Xwz的博客
06-29 756
私有成员变量rent：它是Rent接口的一个实现，代表被代理的对象。setRent 方法：用于设置代理的目标对象。getProxy 方法：利用ProxynewProxyInstance方法生成代理对象。这个方法需要三个参数：类加载器，接口数组（代理类需要实现的接口），以及一个InvocationHandler实例（当前对象this）。invoke 方法：这是代理实例的方法调用时实际执行的代码。invoke方法可以在调用目标方法前后添加自定义逻辑，本例中只是简单地调用了目标对象的相应方法。//租房。
Spring动态代理，aop 注解实现aop
都市桃源
10-23 1047
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"
注解的方式实现动态代理基于SpringAOP
weixin_30819163的博客
07-14 208
1.配置spring容器 导入jar包　　 　　　　com.springsource.net.sf.cglib-2.2.0.jar 　　　　com.springsource.org.aopalliance-1.0.0.jar 　　　　com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar 　　　　commons-logging-1.1....
spring 中使用动态代理（注解方式）
记录点滴
06-21 947
上边文章记录Spring中使用动态代理，切面我们是 重写了AfterReturningAdvice 接口和MethodBeforeAdvice 接口中的方法，下边记录自定义切面，我们自定义的切面不能控制目标类、方法，局限性很大： 定义自定义切面 - diyPoint package com.lxc.diy; public class diyPoint { public void beforeLog() { System.out.println("前置切面"); ...
以注解方式模拟Spring IoC AOP
09-12
- **基于代理的AOP**：Spring使用JDK动态代理或CGLIB动态代理创建目标对象的代理，代理对象在调用目标方法前后执行切面逻辑。 - **基于注解的AOP**：Spring支持在方法上直接定义切面注解，如`@Before`, `@After`, `...
Spring注解实现IOC和AOP
weixin_73468155的博客
08-29 526
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考AspectJ 面向切面的框架，它扩展了Java语言，定义了AOP 语法，能够在编译期提供代码的织入。...
Spring IOC和Spring AOP_spring aop_springIOC
09-24
Spring框架是Java开发中最常用的轻量级框架之一，它的核心特性包括依赖注入（Dependency Injection，简称DI）和面向切面编程（Aspect-Oriented Programming，简称AOP）。这两个概念是Spring框架的基石，极大地简化了...
SpringIOC和AOP原理设计模式
01-27
Spring框架的核心特性主要体现在Spring的IOC（Inversion of Control，控制反转）和AOP（Aspect-Oriented Programming，面向切面编程）上。这两个概念在实际的软件开发中扮演着非常重要的角色，能够极大地提高代码的...
Java 注解+动态代理的一个实例
09-22
学习下动态代理模式（关于代理的基础只是有很多帖子都有我就不重复了），做了个注解动态代理的例子， 给那些学习注解或动态代理的初学者。
注解和动态代理
qq_58000391的博客
06-22 951
注解和动态代理的基础知识
4.注解，反射，动态代理
独孤东方朔的博客
08-16 199
自定义注解使用 @interface使用 @interface 定义注解时，意味着它实现了 java.lang.annotation.Annotation 接口，即该注解就是一个Annotation。定义 Annotation 时，@interface 是必须的。注意：它和我们通常的 implemented 实现接口的方法不同。Annotation 接口的实现细节都由编译器完成。通过 @interface 定义注解后，该注解不能继承其他的注解或接口。/**......
注解&动态代理 笔记
dustdawn的博客
04-26 185
注解 @xxx 什么是注解，注解作用 注解就是符合一定格式的语法 @xxxx 注解作用： 注释：在阅读程序时清楚----给程序员看的 注解：给jvm看的，给机器看的 注解在目前而言最主流的应用：代替配置文件 关于配置文件与注解开发的优缺点： 注解优点：开发效率高 成本低 注解缺点：耦合性大 并且不利于后期维护 jdk5提供的注解 @Override：告知编译器此方法是覆盖父类的 @Depre...
注解和动态代理详解
qq_41523340的博客
03-08 694
参考书:《Java核心技术·卷Ⅱ》 1. 注解 注解的作用是对Java中类，方法，成员变量做标记，然后进行特殊处理。例如，Junit框架中，@Test加在方法上，该方法可以被当成测试方法执行，而没有标记的就不能当作测试方法执行。 1.1 自定义注解 自定义注解就是自己设计一个注解来使用。书写的格式如下： public @interface 注解名称 { public 属性类型 属性名() default 默认值; } 在注解中，如果只有一个value属性，在使用该属性时可以省略value名称不写，但是如
Spring的aop动态代理技术注解配置版
qq_40967319的博客
03-18 290
目标对象： package cn.itcast.day02; public class TargetServiceImpl implements TargetService { public void add() { System.out.println("add"); } public void update() { Syst...
注解+动态代理的一个例子
不知所云
03-14 233
在公司没事干了，学习下动态代理模式（关于代理的基础只是有很多帖子都有我就不重复了），做了个注解动态代理的例子，给那些学习注解或动态代理的初学者。 花了将近1小时，没做个什么优化，大牛勿喷。 几个主要的类： 注解类： package test2; import java.lang.annotation.ElementType; import java.lang.annotation....
Java注解+动态代理
weixin_34405354的博客
10-06 290
为什么80%的码农都做不了架构师？>>> ...
Spring IOC与AOP：控制反转与依赖注入详解
Spring IOC (Inversion of Control) 和 AOP (Aspect-Oriented Programming) 是Spring框架中两个核心的概念，它们在现代软件开发中扮演着关键角色，尤其在模块化、可维护性和松耦合方面具有显著优势。 **Spring IOC ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值