Java基础加强，对象的三种增强方式，重点学习动态代理设计模式（为spring框架打基础）

最新推荐文章于 2024-04-27 16:45:19 发布
最新推荐文章于 2024-04-27 16:45:19 发布
阅读量470 收藏
点赞数
分类专栏： java学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43122641/article/details/88764254
版权

技术分析: 动态代理


    面试题: 问 增强一个对象的方法有几种方式?

             1 继承
                      条件: 得知道要继承的类是谁


             2 装饰者模式
                
                不需要知道父类是谁 只需要知道接口即可
                
                条件:
                    1 装饰者和被装饰需要实现同一个接口
                    2 装饰者有被装饰者的引用

                    100方法---适配器类

                缺点: 工作量大

            3 动态代理 
                代理的概念: 图
                
                条件:
                    1 必须得知道要被代理的类/对象是谁

            
            动态代理:动态的给我们生成代理类/代理对象
                    动态: 这个东西我们不用写,java已经给我们提供好了
            JDK的动态代理:
            Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 
                    返回一个指定接口的代理类实例     
                    
            
            扩展: CGLIB的动态代理(导包)

                
            要求:
                1 动态里的概念和作用
                2 JDK的动态代理方式代码能写出来 (案例写出来)
                            // 后期的框架是封装好的 但是建议写出来

        细节1 :
            proxyPerson.run(); // 执行这个方法  invoke都会执行一遍   执行的内容就是针对该方法的增强

        细节4:
            判断 只对某个方法增强 别的方法不增强

        细节2:
            返回值 return  谁调用返回给谁 返回的内容就是最终值

        细节3:
            参数的问题

   总结: 给我一个对象.我就可以对这个对象的接口所有方法进行增强

 

 

 

1，继承的方式实现对象增强

接口
package com.it.extendsObject;

public interface Person {
	public void run();
}

被增强对象
package com.it.extendsObject;

public class puTongPerson implements Person {
//普通人
	@Override
	public void run() {
		System.out.println("跑。。。");
		
	}

}

增强的对象

package com.it.extendsObject;

public class SupPerson extends puTongPerson {
	//超人
	@Override
	public void run() {
		super.run();
		System.out.println("增强了：飞。。。。");
	}
}

测试类
package com.it.extendsObject;

import org.junit.Test;

public class demo1 {
	@Test
	public void test() {
		puTongPerson p=new puTongPerson();
		// 需求:对普通人的走方法进行增强  由走变成飞---增强一个对象的方法
		// 用继承来实现需求
		SupPerson sp=new SupPerson();
		sp.run();
	}
}

结果

2.使用装饰者模式进行对象增强

 如果接口里面有多个方法，装饰着模式工作量巨大，需要全部重写里面的方法
 解决方式：使用动态代理来增强对象

接口
package com.it.DecoratorPattern;

public interface Person {
	public void run();
//	public void run1();
//	public void run2();
//	public void run3();
//	public void run4();
//	public void run5();
//	public void run6();
}

被增强对象

package com.it.DecoratorPattern;

public class puTongPerson implements Person {
//普通人
	@Override
	public void run() {
		System.out.println("跑。。。");
		
	}

//	@Override
//	public void run1() {
//		// TODO Auto-generated method stub
//		
//	}
//
//	@Override
//	public void run2() {
//		// TODO Auto-generated method stub
//		
//	}
//
//	@Override
//	public void run3() {
//		// TODO Auto-generated method stub
//		
//	}
//
//	@Override
//	public void run4() {
//		// TODO Auto-generated method stub
//		
//	}
//
//	@Override
//	public void run5() {
//		// TODO Auto-generated method stub
//		
//	}
//
//	@Override
//	public void run6() {
//		// TODO Auto-generated method stub
//		
//	}

}

增强的对象

package com.it.DecoratorPattern;

public class SupPerson implements Person {
	private puTongPerson p;
	// 被装饰者的引用
	// 如果person接口里面又多个方法，装饰着模式工作量巨大，需要全部重写里面的方法
	// 解决方式：使用动态代理来增强对象
	
	public SupPerson(puTongPerson p) {
		this.p=p;
	}
	public SupPerson() {
		super();
		// TODO Auto-generated constructor stub
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		p.run();
		System.out.println("增强了：飞。。。");
	}
//	@Override
//	public void run1() {
//		// TODO Auto-generated method stub
//		
//	}
//	@Override
//	public void run2() {
//		// TODO Auto-generated method stub
//		
//	}
//	@Override
//	public void run3() {
//		// TODO Auto-generated method stub
//		
//	}
//	@Override
//	public void run4() {
//		// TODO Auto-generated method stub
//		
//	}
//	@Override
//	public void run5() {
//		// TODO Auto-generated method stub
//		
//	}
//	@Override
//	public void run6() {
//		// TODO Auto-generated method stub
//		
//	}

}

测试类
package com.it.DecoratorPattern;

import org.junit.Test;

public class demo2 {
	@Test
	public void test() {
		
		puTongPerson p = new puTongPerson();
		// 假装不知道实现类 但是由需要对普通人的run方法进行增强
		// 装饰者解决这样的需要
		// 条件 : 1 装饰者和被装饰者实现同一个接口   Person
		//   	  2 装饰者里面有被装饰者的引用    在我出生的时候,你把你给我 我要对你进行增强
		SupPerson sp=new SupPerson(p);
		sp.run();
	}
}

3.动态代理设计模式

 

接口
package com.it.DynamicProxy;

public interface Person {
	public void run();
	public String sleep();
	public String eat(String ss);
}


package com.it.DynamicProxy;

被增强的对象
public class puTongPerson implements Person {
//普通人
	@Override
	public void run() {
		System.out.println("跑。。。");
		
	}

	@Override
	public String sleep() {
		System.out.println("睡着了");
		return "sleep";
	}

	@Override
	public String eat(String ss) {
		System.out.println("吃了："+ss);
		return "吃饱了";
	}
}

测试类
package com.it.DynamicProxy;

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

import org.junit.Test;

public class demo3 {
	@Test
	public void text() {
		// 要被增强的对象
		final puTongPerson p=new puTongPerson();
		// 需求: 使用动态代理的方式对普通人进行增强
		// jdk提供的类和方法可以给咱们动态的生成代理对象/增强对象 不需要自己去创建增强类
		/*参数概述: 固定死的
		 *  参数1: 和要被增强的对象一样的类加载器
		 *  参数2: 和要被增强的对象一样的接口
		 *  					1 根据指定的传递接口 返回一个该接口下的实例
		 *  					2 传递的接口 里面的方法就是可以被增强的所有方法
		 *  
		 *  参数3: 所有的增强业务逻辑实现 (方法)
		 * */
		Person ps = (Person) Proxy.newProxyInstance(
				p.getClass().getClassLoader(),
				p.getClass().getInterfaces(),
				new InvocationHandler() {//匿名内部类
					/*参数概述 固定死的
					 * 参数1:不用管 永远是固定值    代理对象的类型 
					 * 参数2: 要被增强的方法
					 * 参数3: 要被增强的方法运行过程中需要的参数
					 * */
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						// TODO Auto-generated method stub
                        //判断是否是需要增强的方法
						if ("eat".equals(method.getName())) {
							// 让以前的方法执行
							// 参数1:本身应该执行这个方法的对象
							// 参数2: 执行这个方法需要的参数
							Object invoke = method.invoke(p, args);
							System.out.println(invoke);
							// 写增强业务逻辑
							System.out.println("增强了：飞....");
							// 最终返回值 谁调用返回给谁
							return "飞起来了";
						}else {
							return "abcd";
						}
					}
				});
		ps.run();// 执行这个方法  invoke都会执行一遍   执行的内容就是针对该方法的增强
		String sleep = ps.sleep();
		//System.out.println(sleep);
		String eat = ps.eat("汉堡");
		System.out.println(eat);
	}
}

结果：

Exception.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
动态代理和增强类
m0_68968100的博客
03-31 143
动态代理和增强类
动态代理
weixin_40974880的博客
09-30 139
1、package cn.itcast.proxy; public interface SaleComputer { public String sale(double money); public void show(); } 2、package cn.itcast.proxy; public class Lenovo implements SaleComputer{ @Override pub...
Java-增强对象的三种方式
DurantJiang Blogs
04-23 2665
一：继承 子类继承父类，拥有父类的特性并且可以扩展自己的功能 我们知道，子类继承父类时，可以重写，重载父类的方法，并且可以增加子类自己的属性。 例如；我们定义一个类Man，有如下属性和功能： class Man{ private String name; private Integer age; public Man(String name,Integer a...
通俗易懂，值得收藏的 java 设计模式实战，装饰者模式 之 你不用改变，就让你的能力变强了_java 装饰者模式 实战
最新发布
2401_84166896的博客
04-27 285
网络百科如下：装饰模式指的是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。设计模式和编程语言无关，但是二当家的依然用Java语言去实战举例。
JAVA面向对象增强
u010466053的博客
11-22 206
设计模式(理解) (1)面试对象的常见设计原则 单一 开闭 里氏 依赖注入 接口 迪米特 (2)设计模式概述和分类 A:经验的总结 B:三类 创建型 结构型 行为型 (3)改进的设计模式 A:简单工厂模式 B:工厂方法模式 C:单例模式(掌握) a:饿汉式 b:懒汉式 (4)Runtime JDK提供的一个单例模式应用的类。 还可以调用dos命令。
面向对象的设计模式
Kevin的专栏
01-05 1295
设计模式：模式是一种问题的解决思路，它已经适用于一个实践环境，并且可以适用于其他环境。 设计模式的分类：分布式编程模式，用户界面模式，数据模型模式三大类。 设计模式的作用：         设计的重用；         为设计提供共同的词汇，每个模式名就是一个设计词汇，其概念使得程序员的交流变得方便；         在开发文档中采用模式词汇可以让其他人更容易理解你的想法。
java方法增强的三种方式
qq_38634814的博客
08-15 3933
在实际开发中，我们往往需要对某些方法进行增强，常用的方法增强的方式有三种，下面就简单介绍一下三种方式的使用以及特点 需求： 有一个Animal接口，提供了抽象方法eat(),有一个猫类实现了Animal接口，重写了eat方法 class Animal { public void eat(); } class Cat implements Animal{ @Override ...
Java资源 学习javaWeb的知识，为后面的Spring打好基础
06-21
本资源聚焦于JavaWeb的学习，旨在为后续深入学习Spring框架打下坚实的基础。 JavaWeb的核心概念主要包括Servlet、JSP（JavaServer Pages）、过滤器（Filter）和监听器（Listener）。Servlet是JavaWeb应用程序的主要...
Java学习零基础到架构师学习路线
04-11
同时，通过JDBC（Java Database Connectivity），学习如何与数据库进行交互，包括DAO（数据访问对象）设计模式、预编译语句、事务处理和数据库连接池的使用。 阶段3：Web前端基础 这一阶段，学习者将涉足前端开发，...
Javaweb开发学习路线及Java三大框架分享？共4页
10-30
1. **Spring框架**：Spring是企业级Java应用的事实标准，它提供了依赖注入（DI）、AOP（面向切面编程）、MVC（Model-View-Controller）框架等。学习Spring，要理解IoC容器的工作机制，掌握Spring Boot和Spring Cloud...
java三大框架
10-31
Hibernate允许开发者用面向对象的方式操作数据库，将Java对象直接映射到数据库表，大大减少了与SQL打交道的工作量。它支持多种数据库，并提供了丰富的查询语言HQL（Hibernate Query Language）和 Criteria API，使得...
java开发最基础的操作.zip
01-25
Java开发是最广泛使用的编程语言之一，尤其在企业级应用领域占据主导地位。这份"java开发最基础的操作.zip...随着熟练度的提高，你将能够进一步探索高级主题，如设计模式、框架（如Spring）、并发编程和分布式系统。
【Java】利用动态代理模式来增强方法功能
MarconiYe的博客
04-13 1124
代理模式作为设计模式的一种，在各大框架的功能底层发挥很重要的作用，比如Spring的AOP，其底层就是用到了动态代理的技术思想,其基本步骤如下： 创建接口： package com.pojo; public interface ShowInfo { String showInfo(); } 创建类实现接口 package com.pojo; public class User implements ShowInfo{ private String name; pr.
使用动态代理增强对象的方法
Hiyiin的博客
05-12 583
一、什么是动态代理，动态代理能干什么？ 简单的说，动态代理就是，在程序运行期，创建目标对象的代理对象，并对目标对象中的方法进行功能性增强的一种技术。 举个栗子，比如你创建了一个类1，里面定义了一个计算a+b的值的方法1，假如你需要在类2中计算a+b+c的值，这个时候你不想再new一个方法，因为前面的a+b的方法，可以做前面一部分的工作了。但是你又不能直接去修改前面那个a+b的方法，因为很多其他的地方用到过方法1，一旦修改了方法1，必然会牵扯到很多不必要的麻烦。这个时候你就可以用动态代理的方法去增强类1中的方
javaAgent动态字节码增强技术示例介绍~~
dylan的博客
11-10 484
javaAgent字节码增强技术，依赖于javassist，java探针分析
Spring AOP解释动态代理增强的的位置对应于AOP中通知（增强）的类型
jiatai_的博客
08-08 313
用动态代理方式对业务方法进行增强的方式相对于AOP中的通知类型图 jdk动态代理拦截到的方法增强图 AOP拦截方法后的增强（通知） 通知类日志方法 public class Logger { /** * 前置通知 */ public void beforePrintLog(){ System.out.println("前置通知Logger...
spring-aop动态代理功能增强步骤(Aspectj)
weixin_45608102的博客
03-01 278
1.加入Aspectj的maven依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>4.3.19.RELEASE</version> </dependency> 2.编写接口(jdk动态代理需要实现接口)
Java字节码的动态生成和增强
Tibib的专栏
01-11 3180
Java字节码的动态生成      实例         package test; import java.lang.reflect.Method; import java.net.URI; import java.net.URISyntaxException; import java.util.Arrays; import javax.tools.JavaCo
使用代理模式实现Spring AOP的面向切面编程，动态代理的四种增强处理
Java开发，人工智能，边缘计算，致力于掌握前沿技术
07-28 1064
什么是代理类？ 代理就是代替我们去执行一些额外的工作。 目标类:只有核心功能的类 比如我们在写service的时候，调用dao方法是我们的核心业务，而service类中的日志记录，事务处理，异常处理等都属于额外的功能，每个service方法中都要写一次这些额外功能也会造成大量代码的冗余， 而面向切面编程的意思就是说把这些公共的、额外的代码功能抽取出来，每个service里面只写我们的核心业务，这样...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Exception.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值