近期看到一些设计模式的文章，自己也有了些想法。
现公司是个爱出差的公司，不可避免要买许多火车票。这个买票的流程一直在变化。
最开始大家都是自己买火车票，然后回公司的时候报销。
就像这样：
public class AtFirst {
public static void main(String[] args) {
EmployeeABuy. Abuy();
//报销
EmployeeBBuy. Bbuy();
//报销
}
}
class EmployeeABuy{
public static void Abuy(){
System. out.println( "A买了一张");
}
}
class EmployeeBBuy{
public static void Bbuy(){
System. out.println( "B买了一张");
}
}
适配器模式
后来人越来越多，出差越来越频繁，不仅个人买票多，总体买票也很多，于是，大家商量应该改进一下：火车票由公司购买，员工向公司行政申请，但是行政部很忙，通常就让员工所在部门购买，最后就是行政部买行政部的票，研发部买研发部的票，但是我们只是向行政部要票，传入自己的名字就可以了。反映在程序中就是行政部作为一个适配器，适配来自研发部等部门的购买需求，就像这样：
//行政部-适配器
public class Adapter implements BuyTicket {
RDBuy rdBuy=new RDBuy();
@Override
public void Buy(String name) {
rdBuy.Buy( name);
}
}
interface BuyTicket{
public void Buy(String name);
}
class RDBuy implements BuyTicket{
@Override
public void Buy(String name) {
System. out.println( "研发部帮 " +name +"买了一张火车票" );
}
}
我们买的时候就是这样：
public static void main(String[] args) {
String emploeeName= "研发部-老王" ;
BuyTicket buyer= new Adapter();
buyer.Buy( emploeeName);
}
其实，但就这个流程来说，还可以完善一些：
public class Adapter implements BuyTicket {
public static void main(String[] args) {
String emploeeName= "研发部-老王" ;
BuyTicket buyer= new Adapter();
buyer.Buy( emploeeName);
}
private AdministrationBuy administraionBuy= new AdministrationBuy(); //
RDBuy rdBuy=new RDBuy();
@Override
public void Buy(String name) {
if ( name.contains( "研发")) {
rdBuy.Buy( name);
}
if ( name.contains( "行政")) {
administraionBuy.Buy( name);
}
}
}
interface BuyTicket{
public void Buy(String name);
}
//行政部
class AdministrationBuy implements BuyTicket{
@Override
public void Buy(String name) {
System. out.println( "行政部帮 " +name +"买了一张火车票" );
}
}
//研发部
class RDBuy implements BuyTicket{
@Override
public void Buy(String name) {
System. out.println( "研发部帮 " +name +"买了一张火车票" );
}
}
代理模式：
到后来，行政部增加了人手，可以自己为大家买票了，而且买票这块也需要一些审核登记，不能由着大家胡乱买啊，于是就不让各个部门买了，当然对于我们来说名义上还是公司买。
interface BuyTicket{
public void Buy(String name);
}
class CompanyBuy implements BuyTicket{
@Override
public void Buy(String name) {
System. out.println( name+ "买了一张火车票" );
}
}
//行政部来审核
class AdministraionPoxy implements BuyTicket{
BuyTicket buyTicket;
public AdministraionPoxy(BuyTicket buyTicket){
this. buyTicket= buyTicket;
}
@Override
public void Buy(String name) {
System. out.println( "审核...");
buyTicket.Buy( name);
System. out.println( "记录...");
}
}
我们买的时候
public class Proxy {
public static void main(String[] args) {
BuyTicket employee= new CompanyBuy();
BuyTicket company= new AdministraionPoxy( employee);
company.Buy( "EmployeeABuy");
company.Buy( "EmployeeABuy");
}
}
动态代理：
再后来，我完善了OA流程，大家只知道申请就行了，不用关心怎么谁买，怎么买。
interface BuyTicket{
public void Buy(String name);
}
class CompanyBuy implements BuyTicket{
@Override
public void Buy(String name) {
System. out.println( "经过一系列手续···" +name +"买票了" );
}
}
class AdministraionHandler implements InvocationHandler {
private Object object;
public AdministraionHandler(Object object){
this. object= object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result= null;
System. out.println( "内部审核...");
result= method.invoke( object, args);
System. out.println( "内部记录...");
return result;
}
}
对于好奇的同学，在调用buy方法的时候，再也看不见买的细节了。
public static void main(String[] args) {
BuyTicket buyer= new CompanyBuy();
InvocationHandler handler= new AdministraionHandler( buyer);
BuyTicket proxy=(BuyTicket)Proxy. newProxyInstance(buyer.getClass().getClassLoader(),
buyer.getClass().getInterfaces(), handler);
proxy.Buy( "老王");
}
动态代理内部使用反射构建，关于反射，我会在另一篇文章中说明。