Spring开发入门

Spring开发入门

目录

• Spring开发入门
• 一.通过IDEA创建springboot（helloworld）项目
  • • • 1.file->new->project创建一个新项目
      • 2.选择Spring Initializr，并注意选择自己使用得SDK和java版本。
      • 3.注意点上Spring Web。
• 二.创建RESTful 接口的 Web服务并使用postman测试
  • 一.创建web服务
    • • 1. 按照第一部分创建一个springboot项目
      • 2.创造一个bean包中，创造一个count类以及初始化，及算方法。
      • 3.在controller中创建ResourceController类,将访问的网址和count类的方法所连接.
      • 4.创建另外两个类对后台进行操作.
      • 5.项目已经完成直接运行即可。
  • 二.使用postman测试
• 三.软件设计模式的学习（简单工厂模型、工厂方法模型、抽象工厂模式）
  • • 1.单例模式
    • 2.工厂模式
      • • • 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。
          • 缺点：
    • 3.抽象工厂模式
      • • • 优点：
          • 缺点：

一.通过IDEA创建springboot（helloworld）项目

1.file->new->project创建一个新项目

2.选择Spring Initializr，并注意选择自己使用得SDK和java版本。

3.注意点上Spring Web。

4.这样一个Springboot项目创建完成，可直接打开浏览器localhost:8080访问但是只能看到空白页面。

5.在我的com.example.demo中创建controller包再在其中创建controller类，输入如下代码便可以访问/hello，网页中会返回hello。

二.创建RESTful 接口的 Web服务并使用postman测试

学习模仿于https://www.cnblogs.com/wuyizuokan/p/11117294.html

一.创建web服务

演示的功能就是提供一个计数器功能，可以初始化计数器，修改计数器，查询计数器当前值。没有使用数据库，直接用一个单例类来模拟了，项目结构如下。

1. 按照第一部分创建一个springboot项目

2.创造一个bean包中，创造一个count类以及初始化，及算方法。

3.在controller中创建ResourceController类,将访问的网址和count类的方法所连接.

4.创建另外两个类对后台进行操作.

5.项目已经完成直接运行即可。

二.使用postman测试

1.使用get访问获取初始值，count为0

2.使用put传一个json格式数据，将count赋值为300，再使用get获取发现count变为了300

3.使用post方式访问，传入json格式数据-350，在使用get获取得知count减了-350

三.软件设计模式的学习（简单工厂模型、工厂方法模型、抽象工厂模式）

参考博客https://segmentfault.com/u/tiliaohuzi

1.单例模式

单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。

常见的单例方式实现方式有：懒汉模式、饥汉模式、双重校验锁、静态内部类、枚举等方式实现。

例如通过懒汉模式实现

public class Singleton {
    private static Singleton instance = null;
    private Singleton(){}
    public static Singleton getInstance(){
        //如果还没有被实例化过，就实例化一个，然后返回
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

优点：

单例模式可以保证内存里只有一个实例，减少了内存的开销。可以避免对资源的多重占用。单例模式设置全局访问点，可以优化和共享资源的访问。

缺点：

单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

2.工厂模式

工厂模式是指定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。所有我们在实际开发中，凡是需要生成复杂对象的地方，都可以尝试考虑使用工厂模式来代替。

public class Client {
    //抽象产品
    public interface Product {
        void show();
    }
    //具体产品：ProductA
    static class ConcreteProduct1 implements Product {
        public void show() {
            System.out.println("具体产品1显示...");
        }
    }
    //具体产品：ProductB
    static class ConcreteProduct2 implements Product {
        public void show() {
            System.out.println("具体产品2显示...");
        }
    }
    final class Const {
        static final int PRODUCT_A = 0;
        static final int PRODUCT_B = 1;
        static final int PRODUCT_C = 2;
    }
    static class SimpleFactory {
        public static Product makeProduct(int kind) {
            switch (kind) {
                case Const.PRODUCT_A:
                    return new ConcreteProduct1();
                case Const.PRODUCT_B:
                    return new ConcreteProduct2();
            }
            return null;
        }
    }
}

优点：

用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

缺点：

类的个数容易过多，增加复杂度。增加了系统的抽象性和理解难度。抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

3.抽象工厂模式

抽象工厂（AbstractFactory）模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构，

public class FarmTest {
    public static void main(String[] args) {
        try {
            Farm f;
            Animal a;
            Plant p;
            //读取相应的配置信息，用于生产工厂
            f = (Farm) ReadXML.getObject();
            a = f.newAnimal();
            p = f.newPlant();
            a.show();
            p.show();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}
//抽象产品：动物类
interface Animal {
    public void show();
}
//具体产品：马类
class Horse implements Animal {
    public Horse() {
        System.out.println("具体马类的生成");
    }
    public void show() {
        System.out.println("执行马类的相应操作");
    }
}
//具体产品：牛类
class Cattle implements Animal {

    public Cattle() {
        //具体牛类的生成
        System.out.println("具体牛类的生成");
    }
    public void show() {
        System.out.println("执行马类的相应操作");
    }
}
//抽象产品：植物类
interface Plant {
    public void show();
}
//具体产品：水果类
class Fruitage implements Plant {

    public Fruitage() {
        System.out.println("具体水果类生成");
    }
    public void show() {
        System.out.println("执行水果类的相应操作");
    }
}
//具体产品：蔬菜类
class Vegetables implements Plant {
    public Vegetables() {
        System.out.println("具体蔬菜类生成");
    }
    public void show() {
        System.out.println("执行蔬菜类的相应操作");
    }
}
//抽象工厂：农场类
interface Farm {
    public Animal newAnimal();
    public Plant newPlant();
}
//具体工厂：农场类1
class SGfarm implements Farm {
    public Animal newAnimal() {
        System.out.println("新牛出生！");
        return new Cattle();
    }
    public Plant newPlant() {
        System.out.println("蔬菜长成！");
        return new Vegetables();
    }
}
//具体工厂：农场类2
class SRfarm implements Farm {
    public Animal newAnimal() {
        System.out.println("新马出生！");
        return new Horse();
    }
    public Plant newPlant() {
        System.out.println("水果长成！");
        return new Fruitage();
    }
}

优点：

1.可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。

2.当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。

3.抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

缺点：

当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。

根据以上对抽象工厂模式的分析，我们可以知道抽象工厂模式通常适用于以下场景：

当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。

系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。