网站推广专员面试,推广网站的方法,刘家窑网站建设公司,深圳互联网公司比较多的地方文章目录 常用的设计模式#xff1a;一、单例模式3、懒汉式 - 懒汉式非线程安全4、饿汉式 - 线程安全5、懒汉式和饿汉式区别6、双重检查锁定7、应用场景 二、工厂模式1、简单工厂模式2、工厂模式3、抽象工厂4、总结 三、代理模式1、静态代理2、动态代理jdk自带动态代理 3、Cgl… 文章目录 常用的设计模式一、单例模式3、懒汉式 - 懒汉式非线程安全4、饿汉式 - 线程安全5、懒汉式和饿汉式区别6、双重检查锁定7、应用场景 二、工厂模式1、简单工厂模式2、工厂模式3、抽象工厂4、总结 三、代理模式1、静态代理2、动态代理jdk自带动态代理 3、Cglib代理 常用的设计模式
一、单例模式
java中单例模式是一种常见的设计模式单例模式的写法有好几种这里主要介绍三种懒汉式单例、饿汉式单例、双重检查锁定 1、单例模式有以下特点 a、单例类只能有一个实例。 b、单例类必须自己创建自己的唯一实例。 c、单例类必须给所有其他对象提供这一实例。 2、代码特点 a、私有静态变量 b、私有构造方法 c、公有的静态访问方法
3、懒汉式 - 懒汉式非线程安全
public class Singleton {private Singleton() {}private static Singleton singlenull;//静态工厂方法 public static Singleton getInstance() {if (single null) { single new Singleton();} return single;}
}4、饿汉式 - 线程安全 //饿汉式单例类.在类初始化时已经自行实例化 public class Singleton1 {private Singleton1() {}private static final Singleton1 single new Singleton1();//静态工厂方法 public static Singleton1 getInstance() {return single;}}
饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用以后不再改变所以天生是线程安全的。
5、懒汉式和饿汉式区别 6、双重检查锁定
public static Singleton getInstance() {if (singleton null) { synchronized (Singleton.class) { if (singleton null) { singleton new Singleton(); } } } return singleton; }7、应用场景
a、需要频繁创建的一些类使用单例可以降低系统的内存压力减少 GC。 a、某类只要求生成一个对象的时候如一个班中的班长等。 b、某些类创建实例时占用资源较多或实例化耗时较长且经常使用。 c、某类需要频繁实例化而创建的对象又频繁被销毁的时候如多线程的线程池、网络连接池等。 e、频繁访问数据库或文件的对象。
二、工厂模式
工厂模式是 Java 中最常用的设计模式之一工厂模式模式的写法有好几种这里主要介绍三种简单工厂模式、工厂模式、抽象工厂模式
1、简单工厂模式
这里以制造coffee的例子开始工厂模式设计之旅。
我们知道coffee只是一种泛举在点购咖啡时需要指定具体的咖啡种类美式咖啡、卡布奇诺、拿铁等等。
/*** 拿铁、美式咖啡、卡布奇诺等均为咖啡家族的一种产品* 咖啡则作为一种抽象概念* author Lsj**/
public abstract class Coffee {/*** 获取coffee名称* return*/public abstract String getName();
}/*** 美式咖啡* author Lsj**/
public class Americano extends Coffee {Overridepublic String getName() {return 美式咖啡;}
}/*** 卡布奇诺* author Lsj**/
public class Cappuccino extends Coffee {Overridepublic String getName() {return 卡布奇诺;}
}
/*** 拿铁* author Lsj**/
public class Latte extends Coffee {Overridepublic String getName() {return 拿铁;}
}2、工厂模式
定义了一个创建对象的接口但由子类决定要实例化的类是哪一个工厂方法让类把实例化推迟到了子类。
/*** 定义一个抽象的咖啡工厂* author Lsj*/
public abstract class CoffeeFactory {/*** 生产可制造的咖啡* return*/public abstract Coffee[] createCoffee();}/*** 中国咖啡工厂* author Lsj**/
public class ChinaCoffeeFactory extends CoffeeFactory {Overridepublic Coffee[] createCoffee() {// TODO Auto-generated method stubreturn new Coffee[]{new Cappuccino(), new Latte()};}
}
/*** 美国咖啡工厂* author Lsj**/
public class AmericaCoffeeFactory extends CoffeeFactory {Overridepublic Coffee[] createCoffee() {// TODO Auto-generated method stubreturn new Coffee[]{new Americano(), new Latte()};}}
/*** 工厂方法测试* author Lsj**/
public class FactoryMethodTest {static void print(Coffee[] c){for (Coffee coffee : c) {System.out.println(coffee.getName());}}public static void main(String[] args) {CoffeeFactory chinaCoffeeFactory new ChinaCoffeeFactory();Coffee[] chinaCoffees chinaCoffeeFactory.createCoffee();System.out.println(中国咖啡工厂可以生产的咖啡有);print(chinaCoffees);CoffeeFactory americaCoffeeFactory new AmericaCoffeeFactory();Coffee[] americaCoffees americaCoffeeFactory.createCoffee();System.out.println(美国咖啡工厂可以生产的咖啡有);print(americaCoffees);}
}3、抽象工厂
提供一个接口用于创建相关或依赖对象的家族而不需要明确指定具体类。
在上述的场景上继续延伸咖啡工厂做大做强引入了新的饮品种类茶、 碳酸饮料。中国工厂只能制造咖啡和茶美国工厂只能制造咖啡和碳酸饮料。
如果用上述工厂方法方式除去对应的产品实体类还需要新增2个抽象工厂茶制造工厂、碳酸饮料制造工厂4个具体工厂实现。随着产品的增多会导致类爆炸。
所以这里引出一个概念产品家族在此例子中不同的饮品就组成我们的饮品家族 饮品家族开始承担创建者的责任负责制造不同的产品。
/*** 抽象的饮料产品家族制造工厂* author Lsj**/
public interface AbstractDrinksFactory {/*** 制造咖啡* return*/Coffee createCoffee();/*** 制造茶* return*/Tea createTea();/*** 制造碳酸饮料* return*/Sodas createSodas();
}/*** 中国饮品工厂* 制造咖啡与茶* author Lsj**/
public class ChinaDrinksFactory implements AbstractDrinksFactory {Overridepublic Coffee createCoffee() {// TODO Auto-generated method stubreturn new Latte();}Overridepublic Tea createTea() {// TODO Auto-generated method stubreturn new MilkTea();}Overridepublic Sodas createSodas() {// TODO Auto-generated method stubreturn null;}}/*** 美国饮品制造工厂* 制造咖啡和碳酸饮料* author Lsj**/
public class AmericaDrinksFactory implements AbstractDrinksFactory {Overridepublic Coffee createCoffee() {// TODO Auto-generated method stubreturn new Latte();}Overridepublic Tea createTea() {// TODO Auto-generated method stubreturn null;}Overridepublic Sodas createSodas() {// TODO Auto-generated method stubreturn new CocaCola();}}/*** 抽象工厂测试类* author Lsj**/
public class AbstractFactoryTest {static void print(Drink drink){if(drink null){System.out.println(产品-- );}else{System.out.println(产品 drink.getName());}}public static void main(String[] args) {AbstractDrinksFactory chinaDrinksFactory new ChinaDrinksFactory();Coffee coffee chinaDrinksFactory.createCoffee();Tea tea chinaDrinksFactory.createTea();Sodas sodas chinaDrinksFactory.createSodas();System.out.println(中国饮品工厂有如下产品);print(coffee);print(tea);print(sodas);AbstractDrinksFactory americaDrinksFactory new AmericaDrinksFactory();coffee americaDrinksFactory.createCoffee();tea americaDrinksFactory.createTea();sodas americaDrinksFactory.createSodas();System.out.println(美国饮品工厂有如下产品);print(coffee);print(tea);print(sodas);}
}4、总结
a、简单工厂不能算是真正意义上的设计模式但可以将客户程序从具体类解耦。
b、工厂方法使用继承把对象的创建委托给子类由子类来实现创建方法可以看作是抽象工厂模式中只有单一产品的情况。
c、抽象工厂使对象的创建被实现在工厂接口所暴露出来的方法中。
工厂模式可以帮助我们针对抽象/接口编程而不是针对具体类编程在不同的场景下按具体情况来使用。
三、代理模式
代理模式即通过代理对象访问目标对象实现目标对象的方法。这样做的好处是可以在目标对象实现的基础上增强额外的功能操作实现对目标功能的扩展。
这涉及到一个编程思想不要随意去修改别人已经写好的代码或者方法有坑。如果需要修改可以通过代理模式实现。
代理模式通常有三种实现写法静态代理、动态代理、Cglib代理
代理模式的UML图 从UML图中可以看出代理类与真正实现的类都是继承了抽象的主题类这样的好处在于代理类可以与实际的类有相同的方法可以保证客户端使用的透明性。
1、静态代理
我们先看针对上面UML实现的例子再看静态代理的特点。 Subject接口的实现
public interface Subject {void visit();
}实现了Subject接口的两个类
public class RealSubject implements Subject {private String name byhieg;Overridepublic void visit() {System.out.println(name);}
}
public class ProxySubject implements Subject{private Subject subject;public ProxySubject(Subject subject) {this.subject subject;}Overridepublic void visit() {subject.visit();}
}具体调用如下
public class Client {public static void main(String[] args) {ProxySubject subject new ProxySubject(new RealSubject());subject.visit();}
}通过上面的代理代码我们可以看出代理模式的特点代理类接受一个Subject接口的对象任何实现该接口的对象都可以通过代理类进行代理增加了通用性。但是也有缺点每一个代理类都必须实现一遍委托类也就是realsubject的接口如果接口增加方法则代理类也必须跟着修改。其次代理类每一个接口对象对应一个委托对象如果委托对象非常多则静态代理类就非常臃肿难以胜任。
2、动态代理
动态代理有别于静态代理是根据代理的对象动态创建代理类。这样就可以避免静态代理中代理类接口过多的问题。动态代理是实现方式是通过反射来实现的借助Java自带的java.lang.reflect.Proxy,通过固定的规则生成。 其步骤如下
编写一个委托类的接口即静态代理的Subject接口 实现一个真正的委托类即静态代理的RealSubject类 创建一个动态代理类实现InvocationHandler接口并重写该invoke方法 在测试类中生成动态代理的对象。 第一二步骤和静态代理一样不过说了。第三步代码如下
public class DynamicProxy implements InvocationHandler {private Object object;public DynamicProxy(Object object) {this.object object;}Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object result method.invoke(object, args);return result;}
}第四步创建动态代理的对象
Subject realSubject new RealSubject();
DynamicProxy proxy new DynamicProxy(realSubject);
ClassLoader classLoader realSubject.getClass().getClassLoader();
Subject subject (Subject) Proxy.newProxyInstance(classLoader, new Class[]{Subject.class}, proxy);
subject.visit();创建动态代理的对象需要借助Proxy.newProxyInstance。该方法的三个参数分别是
ClassLoader loader表示当前使用到的appClassloader。
Class?[] interfaces表示目标对象实现的一组接口。
InvocationHandler h表示当前的InvocationHandler实现实例对象。jdk自带动态代理
java.lang.reflect.Proxy
作用动态生成代理类和对象
java.lang.reflect.InvocationHandler(处理器接口)
可以通过invoke方法实现对真实角色的代理访问每次通过Proxy生成代理类对象时都指定对对应的处理器对象
3、Cglib代理
要实现Cglib代理必须引入cglib.jar 包由于Spring-core包中已经包含了cglib功能且大部分Java项目均引入了spring 相关jar包这边使用spring的cglib来讲解。他俩实现方式都是一样的
public class CglibProxy implements MethodInterceptor {//目标对象private Object obj;public CglibProxy(Object obj){this.objobj;}//给目标对象创建一个代理对象public Object getProxyInstance(){//1.工具类Enhancer en new Enhancer();//2.设置父类en.setSuperclass(obj.getClass());//3.设置回调函数en.setCallback(this);//4.创建子类(代理对象)return en.create();}Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println(CglibProxy---------);return method.invoke(obj,objects);}
}说明可以看出Cglib代理模式实现不需要目标对象一定实现接口故目标对象如果没有实现接口可以使用cglib代理模式。其实Spring的代理模式也是这么实现的。
