自定义注解与设计模式
一、自定义注解
1.1什么是注解?
jdk1.5新增技术的技术之一。简化代码的作用,注解可以理解为插件,是代码级别的插件,在类、方法、成员变量上使用,写法:@xxx。注解不会也不能影响代码的实际逻辑,仅仅起到辅助作用。 注解分类:内置注解(也成为元注解 jdk 自带注解)、自定义注解(Spring框架)
1.2实现自定义注解
元注解的作用是负责注解其他注解。Java5.0定义了4个标准的meta-annotation类型,它们被用来提供对其它 annotation类型作说明。Java5.0定义的元注解:
1.@Target
@Target说明了Annotation所修饰的对象范围:Annotation可被用于 packages、types(类、接口、枚举、Annotation类型)、类型成员(方法、构造方法、成员变量、枚举值)、方法参数和本地变量(如循环变量、catch参数)。在Annotation类型的声明中使用了target可更加明晰其修饰的目标。
1.CONSTRUCTOR:用于描述构造器
2.FIELD:用于描述域
3.LOCAL_VARIABLE:用于描述局部变量
4.METHOD:用于描述方法
5.PACKAGE:用于描述包
6.PARAMETER:用于描述参数
7.TYPE:用于描述类、接口(包括注解类型) 或enum声明
2.@Retention
表示需要在什么级别保存该注释信息,用于描述注解的生命周期(即:被描述的注解在什么范围内有效)
3.@Documented
注释的作用及其javadoc文档生成工具的使用
4.@Inherited
允许子类继承父类的注解
@Target(value = { ElementType.METHOD, ElementType.TYPE }) @Retention(RetentionPolicy.RUNTIME) public @interface OneAnnotation { int beanId() default 0; String className() default ""; String[]arrays(); } //使用: @OneAnnotation(beanId = 123, className = "className", arrays = { "111", "222" }) public void add() { }
1.3实现ORM框架映射(对象关系映射)
完成案例,ORM框架实体类与变字段不一致,底层生成sql语句原理
1.3.1自定义表映射注解
@Target(value = { ElementType.TYPE }) @Retention(RetentionPolicy.RUNTIME) public @interface SetTable { /** * * @methodDesc: 功能描述:自定义表映射注解(对应数据库表名称) */ String value(); }
1.3.2自定义字段属性
/** * @classDesc: 功能描述:(定义字段属性)*/ @Retention(RetentionPolicy.RUNTIME) public @interface SetProperty { /** * @methodDesc: 功能描述:(字段名称)*/ String name(); /** * @methodDesc: 功能描述:(长度)*/ int leng(); }
1.3.3自定义注解代码实现
/** * @classDesc: 功能描述:(使用java自定义注解 模拟ORM框架注解版本 )*/ public class Main { public static void main(String[] args) throws ClassNotFoundException { // 1.反射class Class<?> classForName = Class.forName("com.entity.Sudent"); // 2.获取表名称注解F SetTable setTable = classForName.getAnnotation(SetTable.class); // 3.获取所有的成员属性 Field[] declaredFields = classForName.getDeclaredFields(); StringBuffer sf = new StringBuffer(); sf.append(" select "); String fromName = setTable.value(); for (int i = 0; i < declaredFields.length; i++) { Field field = declaredFields[i]; // 4.属性字段 SetProperty sb = field.getAnnotation(SetProperty.class); sf.append(" " + sb.name() + " "); if (i == declaredFields.length - 1) { sf.append(" from "); } else { sf.append(" , "); } } sf.append(" " + fromName); System.out.println(sf.toString()); } }
二、常用设计模式
2.1什么是设计模式?
设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
2.2设计模式的分类?
总体来说设计模式分为三大类:
创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
其实还有两类:并发型模式和线程池模式。
用一张图片来描述:
2.3设计模式的六大原则
1、开闭原则(Open Close Principle)
开闭原则就是说对扩展开放,对修改关闭。在程序需要进行拓展的时候,不能去修改原有的代码,实现一个热插拔的效果。所以一句话概括就是:为了使程序的扩展性好,易于维护和升级。想要达到这样的效果,我们需要使用接口和抽象类,后面的具体设计中我们会提到这点。
2、里氏代换原则(Liskov Substitution Principle)
里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说,任何基类可以出现的地方,子类一定可以出现。 LSP是继承复用的基石,只有当衍生类可以替换掉基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科
3、依赖倒转原则(Dependence Inversion Principle)
这个是开闭原则的基础,具体内容:真对接口编程,依赖于抽象而不依赖于具体。
4、接口隔离原则(Interface Segregation Principle)
这个原则的意思是:使用多个隔离的接口,比使用单个接口要好。还是一个降低类之间的耦合度的意思,从这儿我们看出,其实设计模式就是一个软件的设计思想,从大型软件架构出发,为了升级和维护方便。所以上文中多次出现:降低依赖,降低耦合。
5、迪米特法则(最少知道原则)(Demeter Principle)
为什么叫最少知道原则,就是说:一个实体应当尽量少的与其他实体之间发生相互作用,使得系统功能模块相对独立。
6、合成复用原则(Composite Reuse Principle)
原则是尽量使用合成/聚合的方式,而不是使用继承。
2.4单例模式
2.4.1什么是单例模式
单例保证一个对象JVM中只能有一个实例,常见单例 懒汉式、饿汉式
什么是懒汉式,就是需要的才会去实例化,线程不安全。
什么是饿汉式,就是当class文件被加载的时候,初始化,天生线程安全。
2.4.2单例写法
懒汉式代码
class SingletonTest { public static void main(String[] args) { Singleton sl1 = Singleton.getSingleton(); Singleton sl2 = Singleton.getSingleton(); System.out.println(sl1 == sl2); } } public class Singleton { // 当需要的才会被实例化 private static Singleton singleton; private Singleton() { } // 由于程序刚开始时,多个线程会同时进入到该方法,if条件满足,导致创建的实例不唯一,所以懒汉式线程不安全, synchronized public static Singleton getSingleton() { if (singleton == null) { singleton = new Singleton(); } return singleton; } }
饿汉式代码
class SingletonTest1 { public static void main(String[] args) { Singleton1 sl1 = Singleton1.getSingleton(); Singleton1 sl2 = Singleton1.getSingleton(); System.out.println((sl1 == sl2)+"-"); } } public class Singleton1 { //当class 文件被加载时初始化,之后调用的都是该实例,所以线程安全 private static Singleton1 singleton = new Singleton1(); private Singleton1() { } public static Singleton1 getSingleton() { return singleton; } }
2.5 工厂模式
2.5.1什么是工厂模式
实现创建者和调用者分离。
简单工厂模式
class CarFactory{ public static Car createCar(String carname){ if("jili".equals(carname)){ return new Jili(); }else if("qirui".equals(carname)){ return new Qirui(); }else if("biyadi".equals(carname)){ return new Biyadi(); } }
}
这样调用Car car=CarFactory.createCar("jili");即可创建一个实例。不过添加新的类型需要修改工厂类代码,不符合开闭原则。
可以将生产汽车的工厂类抽象成一个接口
public interface CarFactory { public Car createCar(); }
再让具体的汽车工厂类实现这个工厂类接口
public class JiliFactory implements CarFactory { public static JiliFactory build() { return new JiliFactory(); } public Jili createCar() { return new Jili(); } } public class Jili implements Car{ public Jili() { System.out.println("生产一辆吉利车。"); } public void drive() { System.out.println("吉利车在开"); } } public static void main(String[] args) { Jili jili = JiliFactory.build().createCar(); jili.drive(); }
2.6代理模式
2.6.1什么是代理?
通过代理空值对象的访问,可以详细访问某个对象的方法,在这个方法调用处理,或调用后处理。既(AOP微实现) ,AOP核心技术面向切面编程。
2.6.2代理应用场景
安全代理:可以屏蔽真实角色
远程代理:远程调用代理类RMI
延迟加载:先加载轻量级代理类,真正需要在加载真实
2.6.3代理的分类
静态代理(静态定义代理类)
动态代理(动态生成代理类)
Jdk自带动态代理
Cglib 、javaassist(字节码操作库)
静态代理需要自己生成代理类
public class XiaoMing implements Hose { @Override public void mai() { System.out.println("我是小明,我要买房啦!!!!haha "); } } class Proxy implements Hose { private XiaoMing xiaoMing; public Proxy(XiaoMing xiaoMing) { this.xiaoMing = xiaoMing; } public void mai() { System.out.println("我是中介 看你买房开始啦!"); xiaoMing.mai(); System.out.println("我是中介 看你买房结束啦!"); } public static void main(String[] args) { Hose proxy = new Proxy(new XiaoMing()); proxy.mai(); } }
动态代理,不需要生成代理类
public interface Hose { /** * @methodDesc: 功能描述:(买房代理) */ public void mai(); } public class XiaoMing implements Hose { public void mai() { System.out.println("我是小明,我要买房啦!!!!"); } } public class JDKProxy implements InvocationHandler { private Object tarjet; public JDKProxy(Object tarjet) { this.tarjet = tarjet; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("我是房产中介.....开始监听你买房啦!"); Object oj = method.invoke(tarjet, args); System.out.println("我是房产中介.....结束监听你买房啦!"); return oj; } } class Test222 { public static void main(String[] args) { XiaoMing xiaoMing = new XiaoMing(); JDKProxy jdkProxy = new JDKProxy(xiaoMing); Hose hose = (Hose) Proxy.newProxyInstance(xiaoMing.getClass().getClassLoader(), xiaoMing.getClass().getInterfaces(), jdkProxy); hose.mai(); } }
CGLIB动态代理
import java.lang.reflect.Method; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; public class Cglib implements MethodInterceptor { public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { System.out.println("我是买房中介 , 开始监听你买房了...."); Object invokeSuper = methodProxy.invokeSuper(obj, args); System.out.println("我是买房中介 , 开结束你买房了...."); return invokeSuper; } } class Test22222 { public static void main(String[] args) { Cglib cglib = new Cglib(); Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(XiaoMing.class); enhancer.setCallback(cglib); Hose hose = (Hose) enhancer.create(); hose.mai(); } }
2.6.4CGLIB与JDK动态代理区别
jdk动态代理是由Java内部的反射机制来实现的,cglib动态代理底层则是借助asm来实现的。总的来说,反射机制在生成类的过程中比较高效,而asm在生成类之后的相关执行过程中比较高效(可以通过将asm生成的类进行缓存,这样解决asm生成类过程低效问题)。还有一点必须注意:jdk动态代理的应用前提,必须是目标类基于统一的接口。如果没有上述前提,jdk动态代理不能应用。
注:asm其实就是java字节码控制.