Mode de modèle (Modèle Motif Method)

Définition d'un squelette d'un algorithme et permet une mise en œuvre des sous-classes fournissent pour une ou plusieurs étapes.

Méthodes Modèle de telles sous-classes sans modifier la structure de l'algorithme, l'algorithme de redéfinir certaines étapes.

Appartenant aux modèles de conception du comportement.

scène applicable:

1. Lentilles parvenir à une partie constante de l'algorithme, et le comportement variable de gauche une sous-classe à réaliser.

2. sous-classe chaque comportement commun est extrait et concentré à un parent commun, ce qui évite la répétition de code.

scène de réalité (par avion):

------ ----- billets FIND dénoyautées la sécurité des avions / problèmes temporaires, laissant ------ l'achèvement de vol / retour lieu

Code du processus:

/**
 * @Author Darker
 * @Descrption 坐飞机的流程
 * @Date : Created in 9:41 2020-3-13
 */
public abstract class TakeAPlane {

    //坐飞机的流程是固定的
    protected final void fly(){

        //买票
        this.buyTick();

        //安检
        this.SecurityCheck();

        //实现流程的微调，如果流程不用微调，可以不用
        if(isAnyThing()){
            //返回
            this.goBack();
        }else{
            //上飞机
            this.selectPlane();
            //飞行完成
            this.CompletionOfFlight();
        }

    }

    protected final void buyTick(){
        System.out.println("买票");
    }

    protected final void SecurityCheck(){
        System.out.println("安检");
    }

    //钩子方法
    protected boolean isAnyThing(){return false;}

    protected final void goBack(){
        System.out.println("临时有事，原路回家");
    }

    protected abstract void selectPlane();

    protected final void CompletionOfFlight(){
        System.out.println("一路平安，飞行完成");
    }
}

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 10:07 2020-3-13
 */
public class TakeAPlaneToHaiHang extends TakeAPlane{

    private boolean anyThing = false;

    public TakeAPlaneToHaiHang(boolean anyThing){
        this.anyThing = anyThing;
    }

    //留给子类的方法
    @Override
    protected void selectPlane() {
        System.out.println("上了海航的飞机，海南航空空姐长得漂亮");
    }

    //重写钩子方法
    @Override
    protected boolean isAnyThing() {
        return this.anyThing;
    }
}

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 10:07 2020-3-13
 */
public class TakeAPlaneToShanHang extends TakeAPlane{

    private boolean anyThing = false;

    public TakeAPlaneToShanHang(boolean anyThing){
        this.anyThing = anyThing;
    }

    //留给子类的方法
    @Override
    protected void selectPlane() {
        System.out.println("上了山航的飞机，山东航空空姐身材好");
    }

    //重写钩子方法
    @Override
    protected boolean isAnyThing() {
        return this.anyThing;
    }
}

Code d'essai:

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 10:13 2020-3-13
 */
public class TakeAPlaneTest {
    public static void main(String[] args) {
        //坐海航
        TakeAPlane haiHang = new TakeAPlaneToHaiHang(false);
        haiHang.fly();

        System.out.println("-------------------------------------------------------");
        //坐山航，但临时有事情，老婆带着小姨子跑了
        TakeAPlane shanHang = new TakeAPlaneToShanHang(true);
        shanHang.fly();
    }
}

Les exemples de certains jeu de logique commune bien, tout simplement le dossier de presse dans la sous-classe d'avance bon processus pour aller là-dessus.

modèle JDBC:

Nous utilisons souvent le cadre de certaines de la couche de données, et seulement besoin de passer un paramètre de SQL retour liste, maintenant que nous regardons ce processus est de savoir comment les opérations spécifiques.

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 10:57 2020-3-13
 */
@Data
public class User {

    private String usename;

    private String password;

    private int age;

    private String addr;
}


/**
 * @Author Darker
 * @Descrption 每行返回映射的处理方式接口
 * @Date : Created in 10:31 2020-3-13
 */
public interface RowMapper<T> {

    T mapRow(ResultSet rs, int rowNum) throws Exception;
}

/**
 * @Author Darker
 * @Descrption  jdbc模板
 * @Date : Created in 10:33 2020-3-13
 */
public abstract class JdbcTemplate {

    private DataSource dataSource;

    public JdbcTemplate(DataSource dataSource){
        this.dataSource = dataSource;
    }

    public List<?> executeQuery(String sql,RowMapper<?> rowMapper,Object[] values){

        try {
            //1.获取连接
            Connection connection = this.getConnection();
            //2.创建语句集
            PreparedStatement preparedStatement =  this.createPrePareStatement(connection,sql);
            //3.执行语句集
            ResultSet resultSet = this.executeQuery(sql,preparedStatement,values);
            //4.处理结果集
            List<?> result = this.paresResultSet(resultSet,rowMapper);
            //5.关闭结果集
            this.closeResultSet(resultSet);
            //6.关闭语句集
            this.closeStatement(preparedStatement);
            //7.关闭连接
            this.closeConnection(connection);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    protected void closeConnection(Connection connection) throws Exception {
        connection.close();
    }

    protected  void closeStatement(PreparedStatement preparedStatement) throws Exception {
        preparedStatement.close();
    }

    protected  void closeResultSet(ResultSet resultSet) throws Exception {
        resultSet.close();
    }

    protected List<?> paresResultSet(ResultSet resultSet, RowMapper<?> rowMapper) throws Exception {
        List<Object> result = new ArrayList<>();
        int rowNum = 1;
        while(resultSet.next()){
            result.add(rowMapper.mapRow(resultSet,rowNum++));
        }
        return result;
    }

    protected  ResultSet executeQuery(String sql,PreparedStatement preparedStatement, Object[] values) throws Exception {
        for(int i=0,len =values.length;i<len;i++){
            preparedStatement.setObject(i,values);
        }
        return preparedStatement.executeQuery();
    }

    protected  PreparedStatement createPrePareStatement(Connection connection, String sql) throws SQLException {
        return connection.prepareStatement(sql);
    }

    public Connection getConnection() throws SQLException {
            return this.dataSource.getConnection();
    }
}

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 10:58 2020-3-13
 */
public class UserDao extends JdbcTemplate {

    public UserDao(DataSource dataSource){
        super(dataSource);
    }

    public List<?> selectAll(){
        String sql = "select * from t_user";
        return super.executeQuery(sql, new RowMapper<Object>() {
            @Override
            public Object mapRow(ResultSet rs, int rowNum) throws Exception {
                User user = new User();
                //字段过多，可以用原型模式优化
                user.setUsename(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setAge(rs.getInt("age"));
                user.setAddr(rs.getString("addr"));
                return user;
            }
        },null);
    }

}

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 11:11 2020-3-13
 */
public class UserDaoTest {
    public static void main(String[] args) {
        //有兴趣的小伙伴可以自己去测试一下，这里我就懒得去拿数据源了
        UserDao userDao = new UserDao(null);
        List<?> result = userDao.selectAll();
        System.out.println(result);

    }
}

Source Application:

jdk code source où l'utilisation d'un modèle de modèle ici?

La réponse est que nous utilisons le plus long AbstractList, nous trouvons qu'il est obtenir un regard sur les méthodes.

Jetez un oeil à abstraite méthode get de sa mise en œuvre pour voir s'il y a une différence, la première est ArrayList

Il est le premier indice de vérifier, puis extraire les éléments, puis regarder ArrayQueue

De toute évidence, il doit être modulo la capacité, la valeur de l'opération à nouveau, mais ils ont beaucoup de méthodes publiques, ce qui est très typique du motif de modèle.

look Let à HttpServlet nous utilisons tous les jours.

Il est le plus logique de traitement de la demande sont écrites, en laissant deux méthodes pour atteindre sous-classe, regardons pourquoi il peut être identifié get, méthode de post.

Passer à la logique commune à l'intérieur a été écrit, à droite, c'est un modèle de motif typique.

Continuer à voir mybatis cadre que nous utilisons souvent

Il a laissé quelques-unes des méthodes de fonctionnement à nous, comme la mise à jour et de l'enquête, sa mise en œuvre sous-classe n'est pas la même chose, il y a peu d'intérêt pour le partenariat peut regarder eux-mêmes.