java工厂

一.工厂模式
工厂模式按照《Java与模式》中的提法分为三类：
1. 简单工厂模式(Simple Factory)
2. 工厂方法模式(Factory Method)
3. 抽象工厂模式(Abstract Factory)
简单工厂
简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。
不修改代码的话，是无法扩展的。


工厂方法
工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。
在同一等级结构中，支持增加任意产品。
工厂方法模式：工厂父类（接口）负责定义产品对象的公共接口，而子类工厂则负责创建具体的产品对象。
目的：是为了把产品的实例化操作延迟到子类工厂中完成，通过工厂子类来决定究竟应该实例化哪一个产品具体对象。
工厂方法模式包含四个部分：
1.抽象产品：产品对象同一的基类，或者是同一的接口。
2.具体的产品：各个不同的实例对象类
3.抽象工厂：所有的子类工厂类的基类，或是同一的接口
4.具体的工厂子类：负责每个不同的产品对象的实际创建


实例
1.抽象的产品类：定义car 交通工具类下：
package factory.simple;


/**
 * 抽象产品角色 交通工具接口 
 */
public interface Car {


    /**
     * 上班函数
     */
    void gotowork();


}
2.定义实际的产品类，总共定义两个，bike 和bus 分别表示不同的交通工具类
package factory.simple;


/**
 * 具体产品角色，自行车
 * 
 */
public class Bike implements Car {
    @Override
    public void gotowork() {
        System.out.println("骑自行车去上班！");
    }


}


package factory.simple;


public class Bus implements Car {


    @Override
    public void gotowork() {
        System.out.println("坐公交车去上班！");
    }


}
3.抽象的工厂接口定义如下：
package factory.factory;


import factory.simple.Car;


/**
 * @author lilin
 * 
 */
public interface ICarFactory {


    /**
     * 获取交通工具
     * 
     * @return
     */
    Car getCar();


}









4.具体的工厂子类，分别为每个具体的产品类创建不同的工厂子类：
package factory.factory;


import factory.simple.Bike;
import factory.simple.Car;


public class BikeFactory implements ICarFactory {


    @Override
    public Car getCar() {
        return new Bike();
    }


}


package factory.factory;


import factory.simple.Bus;
import factory.simple.Car;


public class BusFactory implements ICarFactory {


    @Override
    public Car getCar() {
        return new Bus();
    }


}




5.测试类，来验证下 不同的工厂能够产生不同的产品对象：测试类如下
/**
 * 
 */
package factory.factory;


import org.testng.annotations.Test;


import factory.simple.Car;


public class TestFactory {


    @Test
    public void test() {
        ICarFactory factory = null;
        // bike
        factory = new BikeFactory();
        Car bike = factory.getCar();
        bike.gotowork();


        // bus
        factory = new BusFactory();
        Car bus = factory.getCar();
        bus.gotowork();
    }


}




抽象工厂


抽象工厂是应对产品族概念的。比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。
应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。


抽象工厂模式：提供一个创建一系列的相关的或者依赖的对象的接口，无需指定它们的具体实现类，具体的实践分别在子类工厂中产生。隔离了具体类的生产实现，使得替换具体的工厂实现类很容易。包含有以下模块：
1.抽象产品接口：定义产品的接口，公共的暴露方法。便于实际的产品类实现。
2.具体的产品类:包含实际产品的类的逻辑处理：
3.抽象工厂接口：定义产生系列对象的接口
4.具体的工厂实现：实现抽象的接口工厂，返回具体的产品类的实现。




示例：
1.抽象的产品接口，定义了Car 和 IBreakFast
package factory.simple;


/**
 * 抽象产品角色 交通工具接口
 * 
*/
public interface Car {


    /**
     * 上班函数
     */
    void gotowork();


}


package factory.abstractfactory;


public interface IBreakFast {
    /**
     * 吃早餐
     */
    void eat();
}
2.定义具体的产品类的实现
package factory.simple;


/**
 * 具体产品角色，自行车
 * 
*/
public class Bike implements Car {
    @Override
    public void gotowork() {
        System.out.println("骑自行车去上班！");
    }


}


package factory.simple;


public class Bus implements Car {


    @Override
    public void gotowork() {
        System.out.println("坐公交车去上班！");
    }


}






package factory.abstractfactory;


public class Milk implements IBreakFast {


    @Override
    public void eat() {
        System.out.println("喝牛奶！");
    }


}




package factory.abstractfactory;


public class Orange implements IBreakFast {


    @Override
    public void eat() {
        System.out.println("吃饺子!");
    }


}
3.定义好抽象的工厂接口，一系列的获取实例的接口方法
package factory.abstractfactory;


import factory.simple.Car;


public interface IAbstractFactory {


    /**
     * 
     * @return
     */
    Car getCar();


    /**
     * 
     */
    IBreakFast getBreakFast();


}
4.定义具体的工厂生产类，具体的产品实例返回
package factory.abstractfactory;


import factory.simple.Bike;
import factory.simple.Car;


public class LowPersonFactory implements IAbstractFactory {


    @Override
    public Car getCar() {
        return new Bike();
    }


    @Override
    public IBreakFast getBreakFast() {
        return new Orange();
    }


}




package factory.abstractfactory;


import factory.simple.Bus;
import factory.simple.Car;


public class HighPersonFactory implements IAbstractFactory {


    @Override
    public Car getCar() {
        return new Bus();
    }


    @Override
    public IBreakFast getBreakFast() {
        return new Milk();
    }
}
5.测试
package factory.abstractfactory;


import org.testng.annotations.Test;


import factory.simple.Car;


public class AbstractFactoryTest {


    @Test
    public void test() {
        IAbstractFactory factory = new LowPersonFactory();
        Car car = factory.getCar();
        IBreakFast breakFast = factory.getBreakFast();
        System.out.println("吃的早饭是：");
        breakFast.eat();
        System.out.println("上班交通工具是：");
        car.gotowork();


        IAbstractFactory factory2 = new HighPersonFactory();
        car = factory2.getCar();
        breakFast = factory2.getBreakFast();
        System.out.println("吃的早饭是：");
        breakFast.eat();
        System.out.println("上班交通工具是：");
        car.gotowork();
    }


}
这样使用过程城中，只要注入抽象的工厂接口，具体的产品的产生，会在实际的子类工厂类中产生，也可以随意的添加和修改实际子类工厂类，而不需要改变既有的代码设计


结论：★工厂模式中，重要的是工厂类，而不是产品类。产品类可以是多种形式，多层继承或者是单个类都是可以的。但要明确的，工厂模式的接口只会返回一种类型的实例，这是在设计产品类的时候需要注意的，最好是有父类或者共同实现的接口。
★使用工厂模式，返回的实例一定是工厂创建的，而不是从其他对象中获取的。
★工厂模式返回的实例可以不是新创建的，返回由工厂创建好的实例也是可以的。
区别
简单工厂：用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力）
工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品） 
抽象工厂 ：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族） 
以上三种工厂方法在等级结构和产品族这两个方向上的支持程度不同。所以要根据情况考虑应该使用哪种方法




二.单例模式
是一种常见的软件设计模式。在他的核心结构中只包含一个单列的特殊类。通过单例模式可以保证系统中一个类只有一个实例。即一个类只有一个对象实例


第一种形式:懒汉式


public class SingletonClass {
private SingletonClass() {
}
private static SingletonClass instance = null;
// synchronized  同步方法  保证该方法在某一个时间片只能被一个线程调用
public static synchronized SingletonClass getInstance() {
if (instance == null) {
instance = new SingletonClass();
}
return instance;
}
}


第二种形式:饿汉式
public class Singleton {
private static final Singleton instance = new Singleton();


private Singleton() {
}


// 这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance() {
return instance;
}


}
区别：
懒汉式的特点是延迟加载，比如配置文件，采用懒汉式的方法，顾名思义，懒汉么，很懒的，配置文件的实例直到用到的时候才会加载。。。。。。
饿汉式的特点是一开始就加载了，如果说懒汉式是“时间换空间”，那么饿汉式就是“空间换时间”，因为一开始就创建了实例，所以每次用到的之后直接返回就好了




三.代理模式


好处 :可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.
  这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法
举个例子来说明代理的作用:假设我们想邀请一位明星,那么并不是直接连接明星,而是联系明星的经纪人,来达到同样的目的.明星就是一个目标对象,他只要负责活动中的节目,而其他琐碎的事情就交给他的代理人(经纪人)来解决.这就是代理思想在现实中的一个例子
组成
抽象角色：通过接口或抽象类声明真实角色实现的业务方法。
代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。


模式结构
一个是真正的你要访问的对象(目标类)，一个是代理对象,真正对象与代理对象实现同一个接口,先访问代理类再访问真正要访问的对象。
代理模式分为静态代理、动态代理。
静态代理是由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件(.class文件)，代理类和委托类的关系在运行前就确定了。
动态代理是在实现阶段不用关心代理类，而在运行阶段才指定哪一个对象。 




代理模式的关键点是:代理对象与目标对象.代理对象是对目标对象的扩展,并会调用目标对象
2.1静态代理
静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类.
下面举个案例来解释:
模拟保存动作,定义一个保存动作的接口:IUserDao.java,然后目标对象实现这个接口的方法UserDao.java,此时如果使用静态代理方式,就需要在代理对象(UserDaoProxy.java)中也实现IUserDao接口.调用的时候通过调用代理对象的方法来调用目标对象.
需要注意的是,代理对象与目标对象要实现相同的接口,然后通过调用相同的方法来调用目标对象的方法
代码示例:
接口:IUserDao.java
/**
 * 接口
 */
public interface IUserDao {


    void save();
}


目标对象:UserDao.java
/**
 * 接口实现
 * 目标对象
 */
public class UserDao implements IUserDao {
    public void save() {
        System.out.println("----已经保存数据!----");
    }
}
代理对象:UserDaoProxy.java
/**
 * 代理对象,静态代理
 */
public class UserDaoProxy implements IUserDao{
    //接收保存目标对象
    private IUserDao target;
    public UserDaoProxy(IUserDao target){
        this.target=target;
    }


    public void save() {
        System.out.println("开始事务...");
        target.save();//执行目标对象的方法
        System.out.println("提交事务...");
    }
}


测试类:App.java
/**
 * 测试类
 */
public class App {
    public static void main(String[] args) {
        //目标对象
        UserDao target = new UserDao();
        //代理对象,把目标对象传给代理对象,建立代理关系
        UserDaoProxy proxy = new UserDaoProxy(target);
        proxy.save();//执行的是代理的方法
    }
}
静态代理结论：
1.可以做到在不修改目标对象的功能前提下,对目标功能扩展.
2.缺点:
因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.






2.2动态代理
动态代理有以下特点:
1.代理对象,不需要实现接口
2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要指定创建代理对象/目标对象实现的接口的类型)
3.动态代理也叫做:JDK代理,接口代理


JDK中生成代理对象的API
代理类所在包:java.lang.reflect.Proxy
JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是:
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )
注意该方法是在Proxy类中是静态方法,且接收的三个参数依次为:
ClassLoader loader,:指定当前目标对象使用类加载器,获取加载器的方法是固定的
Class<?>[] interfaces,:目标对象实现的接口的类型,使用泛型方式确认类型
InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入


代码示例:
接口类IUserDao.java以及接口实现类,目标对象UserDao是一样的,没有做修改.
在这个基础上,增加一个代理工厂类(ProxyFactory.java),将代理类写在这个地方,然后在测试类(需要使用到代理的代码)中先建立目标对象和代理对象的联系,然后代用代理对象的中同名方法


代理工厂类:ProxyFactory.java
/**
 * 创建动态代理对象
 * 动态代理不需要实现接口,但是需要指定接口类型
 */
public class ProxyFactory{


    //维护一个目标对象
    private Object target;
    public ProxyFactory(Object target){
        this.target=target;
    }


   //给目标对象生成代理对象
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("开始事务2");
                        //执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("提交事务2");
                        return returnValue;
                    }
                }
        );
    }


}
测试类:App.java
/**
 * 测试类
 */
public class App {
    public static void main(String[] args) {
        // 目标对象
        IUserDao target = new UserDao();
        //原始的类型
        System.out.println(target.getClass());


        // 给目标对象，创建代理对象
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
        // class $Proxy0   内存中动态生成的代理对象
        System.out.println(proxy.getClass());


        // 执行方法 代理对象
        proxy.save();
    }
}


结论：代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理