核心内容摘要
5个高效方法实现局域网设备探测与网络安全监控
单例模式单例模式是指在整个应用中一个类的对象只允许出现一个(类的对象最多 只允许创建一次)我们在创建一个类的对象时调用的是类的构造器所以在单例中类的构 造器只允许调用一次核心构造方法私有化不允许在外部创建类的实例而将类的实例构建 放到类内部实现,在内部通过编码控制实例的创建只能创建一次。
1饿汉模式它是一种对象立即加载(对象立即创建)模式,当类被加载 时该单例对象就被创建,时间效率比较高空间效率低package com.jiazhong.basic.设计模式.单例模式; public class 饿汉单例模式 { private static 饿汉单例模式 instencenew 饿汉单例模式(); private 饿汉单例模式(){} public static 饿汉单例模式 getInstance(){ return instence; } }
2懒汉模式它使用的是懒加载模式实现的单例当需要使用类对象时 才创建该类的单例对象(时间效率比较低空间效率高)package com.jiazhong.basic.设计模式.单例模式; import lombok.SneakyThrows; public class 懒汉单例模式 { private static 懒汉单例模式 instance; private static Object suonew Object(); private 懒汉单例模式() { } SneakyThrows public static 懒汉单例模式 getInstance(){ if (instancenull){ synchronized (suo){ if (instancenull){ Thread.sleep(
; instancenew 懒汉单例模式(); } } } return instance; } }
3枚举单例模式package com.jiazhong.basic.设计模式.单例模式; public enum 枚举单例模式 { INSTANCE; public void a(){ System.out.println(Hello); } public void find(){ System.out.println(find); } }测试类package com.jiazhong.basic.设计模式.单例模式; import lombok.SneakyThrows; import java.lang.reflect.Constructor; public class App { private static void a(){ 饿汉单例模式 i1饿汉单例模式.getInstance(); 饿汉单例模式 i2饿汉单例模式.getInstance(); System.out.println(i
; System.out.println(i
; System.out.println(i1i
; } private static void b1(){ 懒汉单例模式 i1懒汉单例模式.getInstance(); 懒汉单例模式 i2懒汉单例模式.getInstance(); System.out.println(i
; System.out.println(i
; System.out.println(i1i
; } SneakyThrows private static void b2(){ final 懒汉单例模式[] inew 懒汉单例模式[2]; Thread t1new Thread(() - i[0] 懒汉单例模式.getInstance()); Thread t2new Thread(() - i[1] 懒汉单例模式.getInstance()); t
start(); t
start(); Thread.sleep(
; System.out.println(i[0]); System.out.println(i[1]); System.out.println(i[0]i[1]); } SneakyThrows private static void c1(){ Class? aClassClass.forName(com.jiazhong.basic.设计模式.单例模式.饿汉单例模式); Constructor? constructoraClass.getDeclaredConstructor(); constructor.setAccessible(true); Object o1constructor.newInstance(); Object o2constructor.newInstance(); System.out.println(o
; System.out.println(o
; System.out.println(o1o
; } private static void c2(){ 枚举单例模式 i1枚举单例模式.INSTANCE; 枚举单例模式 i2枚举单例模式.INSTANCE; System.out.println(i
; System.out.println(i
; System.out.println(i1i
; i
a(); i
find(); } public static void main(String[] args) { c2(); } }
工厂模式工厂模式分为工厂方法模式和抽象工厂模式创建型模式优点实现对象的创建和对象的使用分离。
将对象的创建交给专门的工厂进行。
产生对象和使用对象分离
代理模式代理模式属于结构型设计模式。
代理模式是指给某一个对象提供一个代理对象并由代理对象控制对原对象的引用。
可以理解为中介。
1静态代理模式静态代理是指代理类由开发人员创建在程序运行前代理对象已被创建自己写一个类去实现接口接口 请客 package com.jiazhong.basic.设计模式.代理模式.静态代理; public interface Treat { void treat(); }老板实现接口 package com.jiazhong.basic.设计模式.代理模式.静态代理; public class Boss implements Treat{ Override public void treat() { System.out.println(我是老板今天我请客吃饭); } }助理实现接口代理类 package com.jiazhong.basic.设计模式.代理模式.静态代理; public class Assistant implements Treat{ private Boss boss; public Assistant(Boss boss) { this.boss boss; } Override public void treat() { boss.treat(); System.out.println(老板不在我来付钱); } } //测试 package com.jiazhong.basic.设计模式.代理模式.静态代理; public class App { public static void main(String[] args) { Boss bossnew Boss();//老板 Assistant assistantnew Assistant(boss);//助理代替老板 assistant.treat(); } } treat应该调用boss但boss没在调用AssistantAssistant可以代替boss实现treat方法
2动态代理
3.
1基于JDK实现重点动态代理把接口写好之后程序在运行过程中会自动地产生当前接口的代理对象。
动态代理是指代理对象在程序运行时通过反射机制(Proxy)动态创建。
动态代理中我们不再需要再手动的创建代理类我们只需要编写一个动态处理器(InvocationHandler)就可以了。
真正的代理对象由 JVM 在运行时为我们动态的来创建。
自动JDK实现的动态代理只支持接口代理不支持类的代理动态代理类 package com.jiazhong.basic.设计模式.代理模式.动态代理.jdk; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.util.Arrays; //动态代理 拦截器 public class DynamicProxyHandler implements InvocationHandler { //代理人 private Object obj; public DynamicProxyHandler(Object obj){ this.objobj; } Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println(我是助理今天老板不在我来付钱); System.out.println(用户调用的方法是:method.getName()); System.out.println(用户传递的参数是 Arrays.toString(args)); //调用目标对象方法 return method.invoke(obj,args); } } 测试 package com.jiazhong.basic.设计模式.代理模式.动态代理.jdk; import com.jiazhong.basic.设计模式.代理模式.动态代理.cjlib.Boss; import java.lang.reflect.Proxy; public class App { public static void main(String[] args) { //目标对象 Boss bossnew Boss(); //
classLoader ClassLoader classLoaderTreat.class.getClassLoader(); //
boss实现的接口 Class[] classes{Treat.class}; //
proxyHandler对象 DynamicProxyHandler proxyHandlernew DynamicProxyHandler(boss); Treat treat(Treat) Proxy.newProxyInstance(classLoader,classes,proxyHandler); System.out.println(treat); treat.diancai(鱼香肉丝);或treat.treat(); } }
3.
3CGLIB代理CGLIB 代理也是一种动态代理该代理支持使用类的子类做为代理对象。
CGLIB 采用了非常底层的字节码技术其原理是通过字节码技术为一个类创建子类并在子类中采用方法拦截的技术拦截所有父类方法的调用 顺势织入横切逻辑。
但因为采用的是继承所以不能对final修饰的类 进行代理。
JDK 动态代理与 CGLib 动态代理均是实现 Spring AOP 的基础。
Enhancer 是一个非常重要的类它允许为非接口类型创建一个 JAVA 代 理Enhancer 动态的创建给定类的子类并且拦截代理类的所有的方法 和 JDK 动态代理不一样的是不管是接口还是类它都能正常工作。
导依赖 AOP dependency groupIdorg.springframework/groupId artifactIdspring-aop/artifactId version
6.
1/version /dependencypackage com.jiazhong.basic.设计模式.代理模式.动态代理.cjlib; import org.springframework.cglib.proxy.MethodInterceptor; import org.springframework.cglib.proxy.MethodProxy; import java.lang.reflect.Method; //动态代理类 public class CGLibProxyHandler implements MethodInterceptor { Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println(今天老板不来我来付钱); return proxy.invokeSuper(obj,args); } }测试类 package com.jiazhong.basic.设计模式.代理模式.动态代理.cjlib; import org.springframework.cglib.proxy.Enhancer; public class App { public static void main(String[] args) { //拦截器的代理方式通过继承的方式实现 继承treat Enhancer enhancernew Enhancer(); //设置其父类 enhancer.setSuperclass(Boss.class); //设置回调 enhancer.setCallback(new CGLibProxyHandler()); //创建代理对象 Boss treat(Boss) enhancer.create(); treat.a(); } }
3.
3手撕MyBatispackage com.jiazhong.basic.设计模式.代理模式.动态代理.手撕Mbatis.handler; import java.io.File; import java.lang.reflect.Field; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class SqlSession implements InvocationHandler { Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { String methodNamemethod.getName(); if (add.equals(methodName)){ Object arg args[0]; // 参数 对象 Class cl arg.getClass(); // 类 String className cl.getSimpleName(); // tableName 类名表名 Field[] declaredFields cl.getDeclaredFields(); // 获取到所有定义的属性 String columns ; String values ; for (int i 0; i declaredFields.length; i) { System.out.println(---------------------------------------------------); Field declaredField declaredFields[i]; System.out.println(declaredField); String fieldName declaredField.getName(); System.out.println(fieldName); columns fieldName ,; // id---getId name---getName toUpperCase大写 String methodGetName get fieldName.substring(0,
.toUpperCase() fieldName.substring(
; System.out.println(methodGetName); Method getMethod cl.getDeclaredMethod(methodGetName); Object result getMethod.invoke(arg); System.out.println(result); values result ,; } //去逗号 columns columns.substring(0, columns.length() -
; values values.substring(0, values.length() -
; // 执行添加操作 String sql insert into className ( columns ) values( values ); System.out.println(sql); //执行 } return null; } //获取到具体mapper接口的“代理”对象 //给什么类的类型会将这个类的具体类型的对象返回出来 public T T getMapper(ClassT tClass){ ClassLoader classLoadertClass.getClassLoader(); Class[] classes{tClass}; return (T) Proxy.newProxyInstance(classLoader,classes,this); } }
观察者模式判断库存rocketmq的延迟消息、观察者模式订阅消息机制、Ai行为观察者模式:指多个对象之间存在一对多的依赖关系当一个对象(服务器|主题)的状态发生改变时 所有依赖它的对象(客户端|观察者)都能自动收到通知并根据通知来决定自己行为。
这种模式有时又被称 为”发布-订阅模式”、“模型-视图模式”。
主题变化了观察者会收到通知分别写成抽象类和具体实现类。
实例购买彩票抽象主题 package com.jiazhong.basic.设计模式.观察者模式; public interface 抽象主题 { void 注册观察者(抽象观察者 gcz); void 通知观察者(); }彩票主题 package com.jiazhong.basic.设计模式.观察者模式; import java.util.ArrayList; import java.util.List; import java.util.Map; public class 彩票主题 implements 抽象主题{ private List抽象观察者 listnew ArrayList(); Override public void 注册观察者(抽象观察者 gcz) { list.add(gcz); } Override public void 通知观察者() { int number(int) (Math.random()*
; list.forEach(e-{ e.接收通知(number); }); } }抽象观察者 package com.jiazhong.basic.设计模式.观察者模式; public interface 抽象观察者 { void 接收通知(int number); }具体观察者彩民观察者 package com.jiazhong.basic.设计模式.观察者模式; public class 彩民观察者 implements 抽象观察者{ private int number(int)(Math.random()*
; private int id; public 彩民观察者(int id) { this.id id; } Override public void 接收通知(int number) { System.out.println(这个彩民购买的号码是:this.number); System.out.println(本次开奖结果是:number); System.out.println(this.numbernumber?恭喜你中奖了:很遗憾下次努力); } }测试类 package com.jiazhong.basic.设计模式.观察者模式; import lombok.SneakyThrows; public class App { SneakyThrows public static void main(String[] args){ 抽象主题 zhutinew 彩票主题(); for (int i 0; i 30; i) { 彩民观察者 cm1new 彩民观察者(i
; zhuti.注册观察者(cm
; } System.out.println(经过了一段时间); for (int i 0; i 10; i) { Thread.sleep(
; System.out.println(.); } System.out.println(); System.out.println(开始通知彩民); zhuti.通知观察者(); } }
装饰者模式装饰者模式动态地将责任(功能)附加到对象上。
若要扩展功能装饰者提供了比继承更有弹性的替代方案。
(
装饰者和被装饰对象有相同的超类。
(
你可以用一个或多个装饰者包装一个对象(被装饰者对象)。
(
既然装饰者和被装饰对象有相同的超类所以在任何需要原始对象 被包装的的场合可以用装饰过的对象代替它。
(
装饰者可以在所委托被装饰者的行为之前与 / 或之后加上自己的 行为不修改它的代码的情况下修改了它的行为以达到特定的目的(
在装饰者的行为(方法中)发起对被装饰者对象的行为(方法)的调用 (
对象可以在任何时候被装饰所以可以在运行时动态地、不限量地用你喜欢的装饰者来装饰对象。
对添加是开放的对修改是关闭的 不修改原来的代码 将类的方法变得更强大但没有修改代码例如陕西人与河北人有一个共同的父类中国人中国人能进的地方陕西人也能进陕西人能进的地方河北人也能进。
示例定义一个人类学生继承人类学生在学习学生不单单会学习他们其中有些人可能还具有其他能力 如唱歌、跳舞等我们通过装饰模式的来为不同的人群添加新的能力//人 package com.jiazhong.basic.设计模式.装饰者模式; public interface Person { void active(); } //学生类 package com.jiazhong.basic.设计模式.装饰者模式; import lombok.Data; Data public class Student implements Person{ private String name; public Student(String name) { this.name name; } Override public void active() { System.out.println(name正在努力学习); } } package com.jiazhong.basic.设计模式.装饰者模式; import lombok.Data; Data public class BigStudent extends Student{ public BigStudent(String name) { super(name); } Override public void active(){ super.active(); System.out.println(super.getName()边唱歌边学习); } }//装饰者类 package com.jiazhong.basic.设计模式.装饰者模式; public class 装饰者 implements Person{ private Person 被装饰者; public 装饰者(Person 被装饰者) { this.被装饰者 被装饰者; } Override public void active() { //添加了我的功能 System.out.println(边唱歌边学习); 被装饰者.active(); } }//测试 package com.jiazhong.basic.设计模式.装饰者模式; public class App { //继承方式 private static void a(){ Person pnew BigStudent(张
; p.active(); } //装饰者方式 private static void b(){ Person pnew Student(张
; 装饰者 zsznew 装饰者(p); zsz.active(); } public static void main(String[] args) { b(); } }
责任链模式责任链模式顾名思义就是用来处理相关事务责任的一条执行链执行链上 有多个节点每个节点都有机会处理请求事务如果某个节点处理完了就可以根据实际业务需求传递给下一个节点继续处理或者返回处理完毕。
示例员工请假审批流程 请假时间 1 天以内项目组长审批即可 请假时间大于 1 天小于等于 3 天则需要项目经理审批 请假时间大于 3 天则需要总经理审批package com.jiazhong.basic.设计模式.责任链模式; public abstract class Handler { private Handler nextHandler; public Handler getNextHandler(){ return nextHandler; } public void setNestHandler(Handler nextHandler){ this.nextHandlernextHandler; } public abstract void active(int day);//接口可以省略public抽象类不可以 } package com.jiazhong.basic.设计模式.责任链模式; public class TM extends Handler{ Override public void active(int day) { System.out.println(组长开始审批); if (day
{ super.getNextHandler().active(day); } } }package com.jiazhong.basic.设计模式.责任链模式; public class PM extends Handler{ Override public void active(int day) { System.out.println(项目经理开始审批); if (day
{ getNextHandler().active(day); } } }package com.jiazhong.basic.设计模式.责任链模式; public class GM extends Handler{ Override public void active(int day) { System.out.println(总经理开始审批); } }package com.jiazhong.basic.设计模式.责任链模式; public class App { public static void main(String[] args) { GM gmnew GM(); PM pmnew PM(); TM tmnew TM(); tm.setNestHandler(pm); pm.setNestHandler(gm); tm.active(
; } }
策略模式锦囊妙计策略模式Strategy定义了一组算法将每个算法都封装起来在使 用时根据不同的环境使用不同的算法(使用时可以互换)package com.jiazhong.basic.设计模式.策略模式; public class 旅游 { private 出行 出行策略; public 旅游(出行 出行策略){ this.出行策略出行策略; } public void 旅游(){ System.out.println(我们准备去西安); 出行策略.出行方式(); } }package com.jiazhong.basic.设计模式.策略模式; //抽象策略 public interface 出行 { void 出行方式(); }package com.jiazhong.basic.设计模式.策略模式; public class 高铁 implements 出行{ Override public void 出行方式() { System.out.println(坐着高铁回西安); } }package com.jiazhong.basic.设计模式.策略模式; public class 飞机 implements 出行{ Override public void 出行方式() { System.out.println(坐着飞机回西安); } }package com.jiazhong.basic.设计模式.策略模式; public class 火车 implements 出行{ Override public void 出行方式() { System.out.println(坐着火车回西安); } }package com.jiazhong.basic.设计模式.策略模式; public class App { public static void main(String[] args) { 出行 cxnew 飞机(); 旅游 lvnew 旅游(cx); lv.旅游(); } }
适配器模式适配器模式是指将一个接口转换成客户希望的另一个接口使接口不兼容 的那些类可以一起工作。
(转换器)适配器模式既可以作为类结构型模式也可以作为对象结构型模式。
在适配器模式中我们通过增加一个新的适配器类来解决接口不兼容的问 题使得原本没有任何关系的类可以协同工作。
实例充电器package com.jiazhong.basic.设计模式.适配器模式; public interface 充电接口 { int output5v(); }package com.jiazhong.basic.设计模式.适配器模式; public class 手机 { public void 充电(充电接口 cdjk){ System.out.println(手机没电了); int icdjk.output5v(); if (i