java的设计模式及代理模式

 JAVA六大设计原则 JAVA设计模式提供六个基本原则，分别是： 开闭原则(OCP) - The Open-Closed Principle 单一职责原则(SRP) - Single Responsibility Principle 里氏替换原则(LSP) - Liskov Substitution Principle 依赖倒置原则(DIP) - Dependency Inversion Principle 接口隔离原则(ISP) - Interface Segregation Principle 迪米特法则(DP) - Demeter Principle JAVA23种设计模式 在软件工程当中，设计原则和设计模式是不同的． ＃　设计原则 设计原则是为了更好的设计软件的高层指导方针．　 它不提供具体的实现方式也不会绑定任何一种编程语言．　　 最常用的原则是SOLID（SRP, OCP, LSP, ISP, DIP）原则 　设计模式 设计模式对关于面向对象问题的具体解决方案． 比如说，　如果你想创建一个类而且它在任何时刻只会有一个对象，那么你就应该使用单例类模式． 设计模式是经过大量检测的安全的做法．

单例设计模式

懒汉式：

package com.apesource.lazytest;public class Test02 { public static void main(String[] args) { Student stu1=Student.getInstance(); Student stu2=Student.getInstance(); System.out.println(stu1==stu2); }}

package com.apesource.lazytest;public class Student { //3。创建static修饰的成员变量 private static Student stu; //1。设计私有构造方法 private Student(){ super(); } //2.提供共有的方法 public static synchronized Student getInstance(){ if(stu==null){ stu=new Student(); } return stu; }}

饿汉式：

package com.apesource.hungrytest;/** * 饿汉式 */public class Student { //创建static修饰的成员变量 private static Student stu=new Student(); //1.设计私有构造方法 private Student(){ super(); } //2.提供共有方法 public static synchronized Student getInstance(){ return stu; }}

package com.apesource.hungrytest;import com.apesource.lazytest.Student;public class Test03 { public static void main(String[] args) { com.apesource.lazytest.Student stu1=com.apesource.lazytest.Student.getInstance(); com.apesource.lazytest.Student stu2= Student.getInstance(); System.out.println(stu1==stu2); }}

代理模式

静态代理：

package com.apesource.statictest;public interface ISinger { public void sing();}

package com.apesource.statictest;public class luhanImp implements ISinger{ @Override public void sing() { System.out.println(\"我们的明天\"); }}

package com.apesource.statictest;public class DailirenImp implements ISinger{ //注入一个代理对象 ISinger singer; public void setSinger(ISinger singer) { this.singer = singer; } @Override public void sing() { System.out.println(\"===跳舞==\"); singer.sing(); }}

package com.apesource.statictest;public class Test01 { public static void main(String[] args) { //1.创建鹿晗(被代理) luhanImp luhanImp=new luhanImp(); //2.创建经纪人(代理) DailirenImp dailirenImp=new DailirenImp(); dailirenImp.setSinger(luhanImp); //3.调用经纪人的唱歌 dailirenImp.sing(); }}

动态代理（proxy）:

1. 动态生成代理对象：
   客户端通过Proxy.newProxyInstance()请求生成代理对象时，JVM 会在内存中动态创建一个类（代理类），该类实现了目标对象的所有接口（如IStar），并生成对应的方法（sing()）。

2. 方法调用转发：
   当客户端调用代理对象的任何方法（如proxyStar.sing()），动态生成的代理类会将调用转发给InvocationHandler的invoke()方法，并传入三个参数：

   • 代理对象本身（proxy）；
   • 当前调用的方法（method，如sing()对应的 Method 对象）；
   • 方法参数（args）。

3. 增强逻辑执行：
   在invoke()方法中，我们可以自由定义增强逻辑：

   • 先执行前置操作（如经纪人的准备工作）；
   • 通过method.invoke(target, args)调用目标对象的实际方法（核心业务）；
   • 再执行后置操作（如经纪人的收尾工作）。

4. 返回结果：
   目标方法的返回值通过invoke()方法返回给客户端，整个过程对客户端透明。

package com.apesource.proxy;public interface ISinger { public void sing();}

package com.apesource.proxy;public class CaiYiImp implements ISinger{ @Override public void sing() { System.out.println(\"===日不落===\"); }}

package com.apesource.proxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.lang.reflect.Proxy;public class Test01 { public static void main(String[] args) { //1.创建被代理对象 final ISinger cai=new CaiYiImp(); //2.创建代理对象// cai.getClass().getInterfaces(), // 被代理对象实现的接口// new InvocationHandler() // 调用处理器 ISinger proxy=(ISinger) Proxy.newProxyInstance(cai.getClass().getClassLoader(),// 类加载器 cai.getClass().getInterfaces(), new InvocationHandler() {// ：实现调用处理器逻辑  @Override  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object object=null; try { //执行被代理对象内的方法 object=method.invoke(cai,args); return object; } catch (Exception e) { return object; }  } });// 这里通过代理对象 proxy 调用 sing() 方法，实际会触发调用处理器的 invoke 方法，最终执行被代理对象 cai 的 sing() 方法。 proxy.sing(); }}

动态代理(cglib)

package com.apesource.cglibtest;public interface ISinger { public void sing();}

package com.apesource.cglibtest;public class TengGeErImp implements ISinger{ @Override public void sing() { System.out.println(\"听了赵雷的成都去了成都，听了王峰的北京去了北京，至今不敢听腾格尔的天堂~\"); }}

package com.apesource.cglibtest;import net.sf.cglib.proxy.Enhancer;import net.sf.cglib.proxy.InvocationHandler;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;public class Test02 { public static void main(String[] args) { //1。创建被代理对象 final ISinger teng = new TengGeErImp(); //2.代理对象 ISinger proxy = (ISinger) Enhancer.create(teng.getClass(), new InvocationHandler() { @Override public Object invoke(Object o, Method method, Object[] objects) throws Throwable { Object obj; try {  obj = method.invoke(teng, objects);  return obj; } catch (IllegalAccessException e) {  return null; } } }); proxy.sing(); }}

动态代理 vs 静态代理（核心区别）

对比维度 静态代理 动态代理（JDK） 代理类创建方式 手动编写，编译期确定 JVM 运行时动态生成，无需手动编写 灵活性 代理类与接口绑定（如 Agent 只能代理 IStar） 可代理任意接口的对象，一个处理器可通用 接口方法变更 需修改代理类（如新增 greet () 需同步实现） 无需修改，自动适配接口所有方法 适用场景 接口固定、方法少的简单场景 接口多变、需要通用代理逻辑的场景（如 Spri

工厂模式

package com.apesource.test;public interface INoodles { public void noodleType();}

package com.apesource.test;public class LanZhouLaMian implements INoodles{ @Override public void noodleType() { System.out.println(\"========来一碗兰州拉面=====\"); }}

package com.apesource.test;public class ReGanMianNoodleImp implements INoodles{ @Override public void noodleType() { System.out.println(\"======来一碗热干面==========\"); }}

package com.apesource.test;public class YouPoMianNoodleImp implements INoodles{ @Override public void noodleType() { System.out.println(\"========来一碗油泼面========\"); }}

package com.apesource.test;/** * 面长 */public class NoodleFactory { /** * 规范下面条类型 */ public static final int NOODLE_YOUPO=1; public static final int NOODLE_REGAN=2; public static final int NOODLE_LANZHOULA=3; /** * 创建面条 * */ public static INoodles getNoodle(int type){ if(type==1){ return new YouPoMianNoodleImp(); }else if(type==2){ return new ReGanMianNoodleImp(); }else if(type==3){ return new LanZhouLaMian(); } return null; }}

package com.apesource.test;public class Test01 { public static void main(String[] args) { NoodleFactory.getNoodle(NoodleFactory.NOODLE_LANZHOULA).noodleType();; NoodleFactory.getNoodle(3).noodleType(); }}

模板模式：

所谓模板板式，就是在父类中定义算法的主要流程，而把一些个性化的步骤延迟到子类中去实现，父类始终控制着整个流程的主动权，子类只是辅助父类实现某些可定制的步骤

public abstract class FatherClass { public final void time(){ study(); work(); aiqing(); } public abstract void aiqing(); public void work() { System.out.println(\"努力工作\"); } public void study() { System.out.println(\"好好学习 天天向上\"); }}

public class SonClass extends FatherClass{ @Override public void aiqing() { System.out.println(\"真诚是唯一的必杀技\"); } @Override public void study() { System.out.println(\"学到很晚才回家睡觉\"); } @Override public void work() { System.out.println(\"以后会努力的工作\"); }}

 public class Test { public static void main(String[] args) { FatherClass fatherClass=new SonClass(); fatherClass.time(); }}