Java中的设计原则和设计模式

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量118 收藏
点赞数
分类专栏： JAVA 理论学习 文章标签： java 设计模式 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaomihu6666/article/details/114625089
版权

这里写自定义目录标题

软件开发流程

1.需求分析文档
2.概要设计文档
3.详细设计文档
4.编码和测试
5.安装与调试
6.升级与维护

常用的设计原则

1.开闭原则（open close principle）

对扩展开放对修改关闭，为了使程序的扩展性好，易于维护和升级。

/**
 * 已经提前定义好的类并且已经经通过了测试，根据开闭原则，不建议在类中进行修改
 * 但是可以进行扩展，可以考虑创建该类的子类SubPerson，以补充新的需求
 */
public class Person {
    //添加成员变量age之后，可能会引起新的问题，
    // 后续涉及到Person类的所有代码都需要进行修改，
    // 此时之前测试人员所作的测试工作都要重新再来一遍。
    //private int age;
    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

/**
 * 继承自Person实现扩展,无需更改父类就可以实现扩展的功能。
 */
public class SubPerson extends Person {
    private int age;
}

2.里氏代换原则（Liskov Substitution Principle）

任何基类可以出现的地方，子类一定可以出现，多使用多态的方式

public class ShapeTest {

    // 自定义成员方法实现将参数指定矩形对象特征打印出来的行为，也就是绘制图形的行为
    // Rect r = new Rect(1, 2, 3, 4);
//    public static void draw(Rect r) {
//        r.show(); // 1 2 3 4
//    }
    // 自定义成员方法实现将参数指定圆形对象特征打印出来的行为
//    public static void draw(Circle c) {
//        c.show(); // 5 6 7
//    }
    // 自定义成员方法实现既能打印矩形对象又能打印圆形对象的特征，对象由参数传入  子类 is a 父类
    // Shape s = new Rect(1, 2, 3, 4);   父类类型的引用指向子类类型的对象，形成了多态
    // Shape s = new Circle(5, 6, 7);    多态
    // 多态的使用场合一：通过参数传递形成了多态
    public static void draw(Shape s) {
        // 编译阶段调用父类的版本，运行阶段调用子类重写以后的版本
        s.show();
    }

    public static void main(String[] args) {

        // Rect r = new Rect(1, 2, 3, 4);
        // r.show();
        ShapeTest.draw(new Rect(1, 2, 3, 4));
        ShapeTest.draw(new Circle(5, 6, 7));
    }
}

3.依赖倒转原则（Dependence Inversion Principle）

尽量多依赖于抽象类和接口而不是具体实现类，这样对子类具有强制性和规范性（模板设计）。这里可以参见java多态实现各种形状的打印策略。

4.接口隔离原则（Interface Segregation Principle）

尽量多使用小接口而不是大接口，避免接口的污染，降低类之间耦合度（关联）。

/**
 * 大接口，可以描述动物的各种行为
 */
public interface Animal {

    void run();//用于描述奔跑行为的抽象方法
    void fly();//用于描述飞行行为的抽象方法
}

/**
 * 小接口，仅对应动物的一种行为
 */
public interface RunAnimal {
    public void run();
}

/**
 * 实现Animal接口之后需要重写其所有的方法，
 * 但是fly方法明显不是Dog拥有的行为
 * 此时用大接口不合适，此时用小接口RunAnimal更合适，
 * 避免了牵一发而动全身
 */
//public class Dog implements Animal {
public class Dog implements RunAnimal {
    @Override
    public void run() {

    }

   /* @Override
    public void fly() {

    }*/
}

5.迪米特法则（最少知道原则）（Demeter Principle）

一个实体应当尽量少与其他实体之间发生相互作用，使系统功能模块相对独立。
高内聚，低耦合。

6.合成复用原则（Composite Reuse Principle）

尽量多使用合成/聚合的方式，而不是继承的方式。

public class AA {

    public void show(){
        System.out.println("这是A类中的show方法");
    }
}

/**
 * 合成复用原则重点是在避免了 java 单继承的缺陷
 */
public class BB /*extends AA*/ {
    //声明一个AA类型的引用作为BB的成员变量，提供构造方法实现初始化，
    // 接下来就可以使用这个成员变量调用AA中的成员方法。这就是合成复用原则
    private AA a;
    public BB(AA a){
        this.a = a;
    }
    public void test(){
        //调用A类中的show方法，如何实现？
        //第一种方式：继承AA
        //第二种方式：使用AA类型的引用
        a.show();
    }
}

常用的设计模式

基本概念

（1）设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
（2）设计模式就是一种用于固定场合的固定套路。

基本分类

（1）创建型模式：单例设计模式、工厂方法模式、抽象工厂模式。
（2）结构性模式：装饰器模式、代理模式
（3）行为型模式：模板设计模式。

单例设计模式

单例设计模式主要分为：懒汉式和饿汉式。懒汉式需要对多线程同步进行处理。
下面给出了懒汉式线程同步的小案例。

/**
 * 单例模式的案例
 * 懒汉式线程同步的实现
 * 使用synchronized关键字。
 */
public class Singleton {
    //2.声明本类类型的引用指向本类类型的对象并使用private static 关键字修饰
    private static Singleton sin = null;//懒汉式，容易造成多线程同步问题。

    //1.私有化成员构造方法，使用private关键字修饰
    private Singleton(){}

    //3.提供公有get方法负责将上述对象返回出去，使用public static 关键字修饰
    //添加synchronized关键，锁上获得对象的方法，此时无论有多少个线程，
    // 仅有一个线程可以调用该方法。

    /**
     * synchronized修饰方法等价于在方法体内部使用synchronized锁上运行时对象
     * @return
     */
    public static /*synchronized */Singleton getInstance(){
        synchronized(Singleton.class) {//Singleton.class运用了反射机制，获得的是当前正在运行的对象
            if (null == sin) {
                sin = new Singleton();
            }
            return sin;
        }
    }
}

优化懒汉式线程同步问题
最大程度的避免频繁的加锁解锁。

/**
 * 单例模式的案例
 * 懒汉式线程同步的实现
 * 使用synchronized关键字。
 */
public class Singleton {
    //2.声明本类类型的引用指向本类类型的对象并使用private static 关键字修饰
    private static Singleton sin = null;//懒汉式，容易造成多线程同步问题。

    //1.私有化成员构造方法，使用private关键字修饰
    private Singleton(){}

    //3.提供公有get方法负责将上述对象返回出去，使用public static 关键字修饰
    //添加synchronized关键，锁上获得对象的方法，此时无论有多少个线程，
    // 仅有一个线程可以调用该方法。

    /**
     * synchronized修饰方法等价于在方法体内部使用synchronized锁上运行时对象
     * @return
     */
    public static /*synchronized */Singleton getInstance(){
       /* synchronized(Singleton.class) {//Singleton.class运用了反射机制，获得的是当前正在运行的对象
            if (null == sin) {
                sin = new Singleton();
            }
            return sin;
        }*/
        if (null == sin){//判断是否是第一次创建对象，如果不是直接返回对象即可，这样避免了了每个线程调用该方法时都需要上锁，即只需要上锁第一次创建对象。
            synchronized(Singleton.class) {//Singleton.class运用了反射机制，获得的是当前正在运行的对象
                if (null == sin) {
                    sin = new Singleton();
                }

            }
        }
        return sin;
    }
}

普通工厂模式

普通工厂模式类图结构
案例

public class SmsSender implements Sender {
    @Override
    public void send() {
        System.out.println("正在发送短信！");
    }
}

public class MailSender implements Sender {
    @Override
    public void send() {
        System.out.println("正在发送邮件....");
    }
}

public class SendFactory {
    //自定义成员方法实现对象的创建
    public Sender produce(String type){
        if ("mail".equals(type)){
            return new MailSender();
        }
        if ("sms".equals(type)){
            return new SmsSender();
        }
        return null;
    }
}

/**
 * 利用普通工厂类中的生产方法produce生产各种类对象。
 */
public class SenderFactoryTest {

    public static void main(String[] args) {
        //缺点：代码复杂，可读性略差
        //优点：扩展性和可维护性更强，尤其是在创建大量对象的前提下
        //1.声明工厂类类型的引用指向工厂类类型的对象
        SendFactory ss = new SendFactory();
        //2.调用生产方法实现对象的创建
        Sender s = ss.produce("mail");
        //3.使用对象调用方法模拟发送消息
        s.send();//控制台输出：正在发送邮件....

        System.out.println("====================");
        //该方式的优点：代码简单，可读性强，   在创建单个对象时有优势
        //缺点：扩展性和可维护性略差
        Sender sender = new MailSender();
        sender.send();

    }
}

缺点：
在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，并且可能出现空指针异常。

多个工厂方法模式

多个工厂方法模式类图结构
小案例：

public class SendFactory {
    //自定义成员方法实现对象的创建
    public Sender produce(String type){
        if ("mail".equals(type)){
            return new MailSender();
        }
        if ("sms".equals(type)){
            return new SmsSender();
        }
        return null;
    }

    public Sender produceMail(){
        return new MailSender();
    }

    public Sender produceSms(){
        return new SmsSender();
    }
}

/**
 * 利用普通工厂类中的生产方法produce生产各种类对象。
 * 利用多个工厂方法模式
 */
public class SenderFactoryTest {

    public static void main(String[] args) {
        //缺点：代码复杂，可读性略差
        //优点：扩展性和可维护性更强，尤其是在创建大量对象的前提下
        //1.声明工厂类类型的引用指向工厂类类型的对象
        SendFactory ss = new SendFactory();
        //2.调用生产方法实现对象的创建
        //Sender s = ss.produce("mail");//利用普通工厂模式
        Sender s = ss.produceMail();//利用多个工厂方法模式
        //缺点：在多个工厂方法模式中，为了能够正确的创建对象，
        // 先需要创建工厂类的对象才能调用工厂类中的生产方法
        //3.使用对象调用方法模拟发送消息
        s.send();//控制台输出：正在发送邮件....

        System.out.println("====================");
        //该方式的优点：代码简单，可读性强，   在创建单个对象时有优势
        //缺点：扩展性和可维护性略差
        Sender sender = new MailSender();
        sender.send();

    }
}

/**
 * 利用普通工厂类中的生产方法produce生产各种类对象。
 * 利用多个工厂方法模式
 */
public class SenderFactoryTest {

    public static void main(String[] args) {
        //缺点：代码复杂，可读性略差
        //优点：扩展性和可维护性更强，尤其是在创建大量对象的前提下
        //1.声明工厂类类型的引用指向工厂类类型的对象
        //SendFactory ss = new SendFactory();
        //2.调用生产方法实现对象的创建
        //Sender s = ss.produce("mail");//利用普通工厂模式
        Sender s = SendFactory.produceMail();//利用多个工厂方法模式
        //缺点：在多个工厂方法模式中，为了能够正确的创建对象，
        // 先需要创建工厂类的对象才能调用工厂类中的生产方法
        //3.使用对象调用方法模拟发送消息
        s.send();//控制台输出：正在发送邮件....

        System.out.println("====================");
        //该方式的优点：代码简单，可读性强，   在创建单个对象时有优势
        //缺点：扩展性和可维护性略差
        Sender sender = new MailSender();
        sender.send();

    }
}

静态工厂方法模式

public class SendFactory {
    //自定义成员方法实现对象的创建
    public Sender produce(String type){
        if ("mail".equals(type)){
            return new MailSender();
        }
        if ("sms".equals(type)){
            return new SmsSender();
        }
        return null;
    }

    public static Sender produceMail(){
        return new MailSender();
    }

    public static Sender produceSms(){
        return new SmsSender();
    }
}

工厂方法模式适合：凡是出现了大量的产品需要创建且具有共同的接口时，可以通过工厂方法模式
进行创建。
上述几种工厂模式的缺点：工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序生产新的产品，就必须对工厂类的代码进行修改，这就违背了开闭原则

抽象工厂模式

抽象工厂模式类图结构
小案例：

public interface Provider {
    //自定义抽象方法描述产品的生产
    Sender produce();
}

public class MailSenderFactory implements Provider {
    @Override
    public Sender produce() {
        return new MailSender();
    }
}

public class SmsSenderFactory implements Provider {
    @Override
    public Sender produce() {
    return new SmsSender();
}
}

public class Packet implements Sender{
    @Override
    public void send() {
        System.out.println("正在发送包裹");
    }
}

public class PacketSenderFactory implements Provider {
    @Override
    public Sender produce() {
        return new Packet();
    }
}

/**
 * 利用普通工厂类中的生产方法produce生产各种类对象。
 * 利用多个工厂方法模式
 * 利用静态工厂模式实现
 * 利用抽象工厂模式实现
 *
 */
public class SenderFactoryTest {

    public static void main(String[] args) {
        //缺点：代码复杂，可读性略差
        //优点：扩展性和可维护性更强，尤其是在创建大量对象的前提下
        //1.声明工厂类类型的引用指向工厂类类型的对象
        //SendFactory ss = new SendFactory();
        //2.调用生产方法实现对象的创建
        //Sender s = ss.produce("mail");//利用普通工厂模式
        Sender s = SendFactory.produceMail();//利用多个工厂方法模式
        //缺点：在多个工厂方法模式中，为了能够正确的创建对象，
        // 先需要创建工厂类的对象才能调用工厂类中的生产方法
        //3.使用对象调用方法模拟发送消息
        s.send();//控制台输出：正在发送邮件....

        System.out.println("====================");
        //该方式的优点：代码简单，可读性强，   在创建单个对象时有优势
        //缺点：扩展性和可维护性略差
        Sender sender = new MailSender();
        sender.send();//正在发送邮件....

        System.out.println("====================");
        //通过抽象工厂模式实现
        Provider provider = new MailSenderFactory();
        Sender sender2 = provider.produce();
        sender2.send();//正在发送包裹

        //抽象工厂模式不会违背开闭原则
        Provider provider1 = new PacketSenderFactory();
        Sender sender3 = provider1.produce();
        sender3.send();
    }
}

装饰器模式

（1）基本概念：装饰器模式就是给一个对象动态的增加一些新功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。
装饰器的类图结构
（2）小案例

public interface Sourceable {
    void method();
}

public class Source implements Sourceable {
    @Override
    public void method() {
        System.out.println("小迷糊迷迷糊糊！");
    }
}

public class Decorator implements Sourceable {
    private Sourceable source;
    public Decorator(Sourceable source){
        this.source = source;
    }

    @Override
    public void method() {
    //当传过来的参数是Source时，利用的是父类引用指向子类对象，此时调用source.method()是在Source类中重写的method方法
        source.method();//保有原有功能不变
        System.out.println("小迷糊装饰之后再也不迷糊");
    }
}

/**
 * 装饰器模式的实现
 */
public class SourceableTest {
    public static void main(String[] args) {
        Sourceable sourceable = new Source();
        sourceable.method();//小迷糊迷迷糊糊！

        System.out.println("==============");
        //接下来使用装饰类实现装饰功能
        Sourceable sourceable1 = new Decorator(sourceable);
        sourceable1.method();
        //小迷糊迷迷糊糊！
        // 小迷糊装饰之后再也不迷糊
    }
}

（3）实际意义：
可以实现一个类功能的扩展
可以动态的增加功能，而且还能动态撤销（继承不行）。
缺点：产生过多相似的对象，不易排错。

代理模式

（1）基本概念：代理模式就是找一个代理类替原对象进行一些操作。比如我们在租房子的时候找中介，再如我们打官司需要请律师，中介和律师在这里就是我们的代理。
（2）小案例：

public class Proxy implements Sourceable {
    private Source source;

    public Proxy(){
        source = new Source();
    }

    @Override
    public void method() {
        source.method();
        System.out.println("proxy和装饰器其实是不一样的");
    }
}


/**
 * 装饰器模式的实现
 * 代理模式的实现
 */
public class SourceableTest {
    public static void main(String[] args) {
        //父类引用指向子类对象
        Sourceable sourceable = new Source();
        sourceable.method();//小迷糊迷迷糊糊！

        System.out.println("==============");
        //接下来使用装饰类实现装饰功能
        //装饰类在利用使用有参数构造方法进行初始化，持有Source类的对象
        Sourceable sourceable1 = new Decorator(sourceable);
        sourceable1.method();
        //小迷糊迷迷糊糊！
        // 小迷糊装饰之后再也不迷糊

        System.out.println("================");
        //代理模式
        Sourceable sourceable2 = new Proxy();
        sourceable2.method();
        //小迷糊迷迷糊糊！
        //proxy和装饰器其实是不一样的
    }
}

（3）实际意义：如果在使用的时候需要对原有的方法进行改进，可以采用一个代理类调用原有方法，并且对产生的结果进行控制，这种方式就是代理模式。使用代理模式，可以将功能划分的更加清晰，有助于后期维护。

代理模式和装饰器模式的比较

装饰器模式通常的做法是将原始对象作为一个参数传给装饰者的构造器，而代理模式通常在一个代理类中创建一个被代理类的对象。

装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。

模板方法模式

（1）基本概念：
模板方法模式主要指一个抽象类中封装了一个固定流程，流程中的具体步骤可以有不同子类进行不同的实现，通过抽象类让固定的流程产生不同的效果。
模板方法模式结构类图

（2）小案例：

public abstract class AbstractCalculator {
    //自定义成员方法实现将参数指定的表达式按照参数指定的规则进行切割并返回计算结果
   public int splitExpression(String exp, String op){
        String[] split = exp.split(op);
        return calculate(Integer.parseInt(split[0]),Integer.parseInt(split[1]));
   }
    //自定义抽象方法实现运算
    public abstract int calculate(int ia, int ib);
}

public class Plus extends AbstractCalculator {
    @Override
    public int calculate(int ia, int ib) {
        return ia + ib;
    }
}

public class Minus extends AbstractCalculator {

    @Override
    public int calculate(int ia, int ib) {
        return ia - ib;
    }
}

测试：

public class AbstractCalculatorTest {
    public static void main(String[] args) {
        AbstractCalculator abstractCalculator = new Plus();
        int res = abstractCalculator.splitExpression("1+1","\\+");//+号转义字符，使用时需要注意
        System.out.println("最终的运算结果是：" + res);//最终的运算结果是：2
    }
}

今日总结：
软件开发流程、常用的设计原则、设计模式的概念和分类、常用的设计模式的详解。必须需要理解透彻。

xiaomihu6666
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
三种设计模式
xkdt613的博客
05-11 380
一．题目分析： 1.简单工厂模式 使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象。它主要由三个角色组成，工厂类，抽象产品角色，具体产品角色。在女娲造人这个题中，男人，女人，女娲工厂类为接口类，机器人都是具体产品角色 2.工厂方法模式 海...
Java设计模式中单一职责原则详解.rar
07-10
其中，"单一职责原则"（Single Responsibility Principle，SRP）是面向对象设计的基本原则之一，也是Java设计模式中的重要组成部分。本篇文章将深入探讨单一职责原则的概念、意义、应用及其在Java编程中的实际运用。...
Java中的23种设计模式与7大原则
10-24 1724
Java中的23种设计模式与7大原则 创建型模式 结构型模式 行为型模式 单一职责原则 里氏替换原则 依赖倒置原则 接口隔离原则 迪米特法则 开闭原则 组合/聚合复用原则
java设计模式七大原则
非淡泊无以明志，非宁静无以致远
06-05 2792
update taotao.tb_content set category_id = 34,sub_title = '24' where title = '1' and sub_title ='23';set后面跟[逗号]，where后面跟[and]
C++七项设计原则与常见设计模式
kuailedegouyibacao的博客
07-13 872
C++七项设计原则和常见设计模式 一、C++面向对象设计的的七大设计原则 单一职责原则: 就是一个类只负责一个职责, 只有一个引起变化的原因。 例如：调制解调器：将连接看作一个职责，数据传送看作一个职责，两者需要分离开； 里氏替换原则：任何基类可以出现的地方,子类一定可 以出现，子类一定要能够被当成基类使用； 例如：手枪，步枪，机关枪，玩具枪等都属于枪，但如果在射击游戏场景中，就不能够使用玩具枪，因此，玩具枪应该单独成为一个类，否则就违反了里氏替换原则； 依赖倒置原则：依赖倒置原则就是要依赖于抽象,不.
Java23种设计模式详解
tanksyg的专栏
04-04 222
设计模式（Design Patterns） 开发资料下载：http://pan.baidu.com/share/link?shareid=3739316113&uk=4076915866#dir/path=%2Fstudy 一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器...
Java中23种设计模式
呜呜老司机的博客家园
10-10 7万+
Java中23种设计模式，包括简单介绍，适用场景以及优缺点等
Java常见设计模式总结
热门推荐
张维鹏的博客
09-18 18万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
Java设计模式之七大设计原则
qq_49529322的博客
04-28 1万+
Java设计模式之七大设计原则 本文对Java设计模式中的七大设计原则进行汇总介绍，提炼最核心的概念。 设计模式总结笔记 一、设计模式七大原则 设计模式的目的： 代码可重用性：相同功能的代码，不用多次编写。 可读性：编程规范性，便于其他程序员的阅读和理解。 可扩展性：当需要增加新的功能的时候，非常方便，称为可扩展性。 可靠性：当我们新增功能后，对原来的功能没有影响。 使程序呈现高内聚、低耦合特性。 1.1、单一职责原则 不遵守单一职责原则： 对类来说的，就是一个类应该只负责一项职责。 比如：Us
重学java的设计模式
05-09
本文将着重探讨创建型模式、结构型模式和行为模式这三大类设计模式，并结合六项设计原则进行深入解析。 首先，我们来看创建型模式。创建型模式关注于对象的创建，它们提供了创建对象的灵活方式，使得代码更具复用性...
解析Java编程中设计模式的开闭原则的运用
09-02
总结起来，开闭原则是Java编程中设计模式的重要组成部分，它有助于构建一个易于扩展、难以修改的系统，从而更好地应对需求变更和系统升级。在实际开发中，我们应该始终牢记这一原则，设计出既稳定又灵活的代码结构。
详解Java设计模式编程中的依赖倒置原则
09-02
依赖倒置原则是面向对象设计的基本原则之一，它在Java设计模式中占据着重要的地位。这一原则强调的是软件实体（如类、模块、函数等）应当依赖于抽象，而不是具体的实现。具体来说，这意味着高层次的模块不应该直接...
Java设计模式常用原则解析
08-19
Java设计模式常用原则解析是软件设计中非常重要的一部分，它能够帮助开发者编写出更加灵活、可维护、可扩展的代码。本文将详细介绍Java设计模式常用原则解析，包括单一职责原则、里氏替换原则、依赖倒置原则、接口...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1204
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 497
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 797
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 273
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 2156
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1354
Java实现拼图小游戏
Java设计模式实践与设计原则解析
在实际开发中，结合Java特性如注解（Annotation）和动态代理（Proxy）等，可以进一步优化设计模式的实现。例如，使用注解配合元数据解析库（如ASM或ByteBuddy）可以在运行时实现某些设计模式，如动态代理模式，以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值