设计模式 -- 桥接模式(Bridge)

/**
 * 消息的统一接口
 * @author Administrator
 */
public interface Message {
    /**
     * 发送消息
     * @param message 要发送的消息内容
     * @param toUser 消息发送的目的人员
     */
    public void send(String message,String toUser);
}

/**
 * 以站内短消息的方式发送普通消息
 * @author Administrator
 */
public class CommonMessageSMS implements Message {

    @Override
    public void send(String message, String toUser) {
        System.out.println("使用站内短消息的方式,发送消息 ‘" + message +"‘ 给" + toUser);
    }
}

/**
 * 以E-mail的方式发送普通消息
 * @author Administrator
 */
public class CommonMessageEmail implements Message {

    @Override
    public void send(String message, String toUser) {
        System.out.println("使用E-mail的方式,发送消息 ‘" + message +"‘ 给" + toUser);
    }
}

/**
 * 加急消息的抽象接口
 * @author Administrator
 */
public interface UrgencyMessage extends Message {
    /**
     * 监控某消息的处理过程
     * @param messageId    被监控的消息的编号
     * @return 包含监控到的数据对象
     */
    public Object watch(String messageId);
}

/**
 * 加急消息 站内通知方式
 * @author Administrator
 *
 */
public class UrgencyMessageSMS implements UrgencyMessage {

    @Override
    public void send(String message, String toUser) {
        message = "加急:" + message;
        System.out.println("使用站内短消息的方式,发送消息 ‘" + message +"‘ 给" + toUser);
    }

    @Override
    public Object watch(String messageId) {
        //获取相应的数据,组织成监控的数据对象,然后返回
        return null;
    }
}

/**
 * 加急消息 邮件通知实现
 * @author Administrator
 */
public class UrgencyMessageEmail implements UrgencyMessage {

    @Override
    public void send(String message, String toUser) {
        message = "加急:" + message;
        System.out.println("使用E-mail的方式,发送消息 ‘" + message +"‘ 给" + toUser);
    }

    @Override
    public Object watch(String messageId) {
        //获取相应的数据,组织成监控的数据对象,然后返回
        return null;
    }
}

/**
 * 定义实现部分的接口
 * @author Administrator
 *
 */
public interface Implementor {
    /**
     * 示例方法,实现抽象部分需要的某些具体功能
     */
    public void operationImpl();
}

/**
 * 抽象部分的接口
 * @author Administrator
 *
 */
public abstract class Abstraction {
    //持有一个实现部分的对象
    protected Implementor impl;
    
    /**
     * 构造方法,传入实现部分的对象
     * @param impl 实现部分的对象
     */
    public Abstraction(Implementor impl){
        this.impl = impl;
    }
    
    /**
     * 示例操作,实现一定的功能
     */
    public void operation(){
        impl.operationImpl();
    }
}

/**
 * 真正的具体实现对象
 * @author Administrator
 *
 */
public class ConcreteImplementorA implements Implementor {
    @Override
    public void operationImpl() {
        //真正的实现
    }
}

/**
 * 真正的具体实现对象
 * @author Administrator
 */
public class ConcreteImplementorB implements Implementor {
    @Override
    public void operationImpl() {
        //真正的实现
    }
}

/**
 * 扩充由Abstraction定义的接口功能
 * @author Administrator
 */
public class RefinedAbstraction extends Abstraction {

    public RefinedAbstraction(Implementor impl) {
        super(impl);
    }

    /**
     * 示例操作,实现一定的功能
     */
    public void otherOperation(){
        //实现一定的功能,可能会使用具体实现部分的实现方法
        //但是本方法更大的可能是使用Abstraction中定义的方法
        //通过组合使用Abstraction中定义的方法来完成更多的功能
    }
}

/**
 * 实现发送消息的统一接口
 * @author Administrator
 */
public interface MessageImplementor {
    /**
     * 发送消息
     * @param message 要发送的消息内容
     * @param toUser 消息发送的目的人员
     */
    public void send(String message,String toUser);
}

/**
 * 抽象的消息对象
 * @author Administrator
 */
public abstract class AbstractMessage {
    //持有一个实现部分的对象
    protected MessageImplementor impl;
    
    /**
     * 构造方法,传入实现部分的对象
     * @param impl 实现部分的对象
     */
    public AbstractMessage(MessageImplementor impl){
        this.impl = impl;
    }
    
    /**
     * 发送消息,转调实现部分的方法
     * @param message 要发送的消息
     * @param toUser 接收消息人员
     */
    public void sendMessage(String message,String toUser){
        this.impl.send(message, toUser);
    }
}

/**
 * 以站内短消息的方式发送消息
 * @author Administrator
 */
public class MessageSMS implements MessageImplementor {

    @Override
    public void send(String message, String toUser) {
        System.out.println("使用站内短消息的方式,发送消息‘"+message+"‘给" + toUser);
    }
}

/**
 * 以E-mail的方式发送消息
 * @author Administrator
 */
public class MessageEmail implements MessageImplementor {

    @Override
    public void send(String message, String toUser) {
        System.out.println("使用E-mail的方式,发送消息‘"+message+"‘给" + toUser);
    }
}

public class CommonMessage extends AbstractMessage {

    public CommonMessage(MessageImplementor impl) {
        super(impl);
    }
    
    @Override
    public void sendMessage(String message, String toUser) {
        //对于普通消息,什么都不干,直接调用父类的方法,把消息发送出去就可以了
        super.sendMessage(message, toUser);
    }
}

public class UrgencyMessage extends AbstractMessage {

    public UrgencyMessage(MessageImplementor impl) {
        super(impl);
    }

    @Override
    public void sendMessage(String message, String toUser) {
        message = "加急:" + message;
        super.sendMessage(message, toUser);
    }
    
    /**
     * 扩展自己的新功能:监控某消息的处理过程
     * @param messageId 被监控的消息的编号
     * @return 包含监控到数据对象
     */
    public Object watch(String messageId){
        //获取相应的数据,组织成监控的数据对象,然后返回
        return null;
    }
}

public class SpecialUrgencyMessage extends AbstractMessage {

    public SpecialUrgencyMessage(MessageImplementor impl) {
        super(impl);
    }

    public void hurry(String messageId){
        //执行催促的业务,发出催促的消息
    }
    
    @Override
    public void sendMessage(String message, String toUser) {
        message = "特急:" + message;
        super.sendMessage(message, toUser);
    }
}

/**
 * 以手机短消息的方式发送消息
 * @author Administrator
 */
public class MessageMobile implements MessageImplementor {
    @Override
    public void send(String message, String toUser) {
        System.out.println("使用手机短消息的方式,发送消息‘"+message+"‘给" + toUser);
    }
}

public class Client {
    public static void main(String[] args) {
        //创建具体的实现对象
        MessageImplementor impl = new MessageSMS();
        //创建一个普通的消息对象
        AbstractMessage m = new CommonMessage(impl);
        m.sendMessage("请喝一杯茶", "小李");
        
        System.out.println("------------------------");
        //创建一个紧急消息对象
        m = new UrgencyMessage(impl);
        m.sendMessage("请喝一杯茶", "小李");
        
        System.out.println("------------------------");
        //创建一个特急消息对象
        m = new SpecialUrgencyMessage(impl);
        m.sendMessage("请喝一杯茶", "小李");
        
        System.out.println("------------------------");
        //把实现方式切换成手机短消息,然后再实现一遍
        impl = new MessageMobile();
        m = new CommonMessage(impl);
        m.sendMessage("请喝一杯茶", "小李");
        System.out.println("------------------------");
        m = new UrgencyMessage(impl);
        m.sendMessage("请喝一杯茶", "小李");
        System.out.println("------------------------");
        m = new SpecialUrgencyMessage(impl);
        m.sendMessage("请喝一杯茶", "小李");
    }
}

使用站内短消息的方式,发送消息‘请喝一杯茶‘给小李
------------------------
使用站内短消息的方式,发送消息‘加急:请喝一杯茶‘给小李
------------------------
使用站内短消息的方式,发送消息‘特急:请喝一杯茶‘给小李
------------------------
使用手机短消息的方式,发送消息‘请喝一杯茶‘给小李
------------------------
使用手机短消息的方式,发送消息‘加急:请喝一杯茶‘给小李
------------------------
使用手机短消息的方式,发送消息‘特急:请喝一杯茶‘给小李

　　　　 String sql = "具体要操作的sql语句";
        //1:装载驱动
        Class.forName("驱动的名字");
        
        //2:创建连接
        Connection conn = DriverManager.getConnection("连接数据库服务的URL","用户名","密码");
        
        //3:创建statement或者是preparedStatement
        PreparedStatement pstmt = conn.prepareStatement(sql);
        
        //4:执行sql,如果是查询,再获取ResultSet
        ResultSet rs = pstmt.executeQuery(sql);
        
        //5:循环从ResultSet中把值取出来,封装到数据对象中去
        while(rs.next()){
            //取值示意,按名字取值
            String uuid = rs.getString("uuid");
            
        }
        //6:关闭
        rs.close();
        pstmt.close();
        conn.close();