Spring简单介绍

官网：spring.io

1，spring是一个开源框架。

　　1，包下载：https://repo.spring.io/release/org/springframework/spring/

　　　　https://mvnrepository.com/artifact/org.slf4j/slf4j-api/2.0.0-alpha1

　　2，导包：commons-logging-1.2.jar

　　　　　　spring-beans-5.3.2.jar

　　　　　　spring-context-5.3.2.jar

　　　　　　spring-core-5.3.2.jar

　　　　　　spring-expression-5.3.2.jar

　　　　　　spring-test-5.3.2.jar

2，spring是分层的JavaEE，一站式轻量级框架。

　　分层的javaEE：

　　　　持久层：--jdbc(性能)、Mybatis()

　　　　视图层：--jsp/servlet

　　　　控制层：--servlet

　　一站式：JavaEE 每层都有解决方案

　　轻量级：spring无侵入式（低耦合，高内聚）

3，spring版本：

　　1，GA 稳定版

　　2，SNAPSHOT 快照版，可以稳定使用，且仍在继续改进

　　3，RELEASE 预览版，内侧版本

4，spring核心：

　　1，ioc & di

　　　　IOC控制反转 Inverse object control

　　　　　　1，控制什么？new对象的权利

　　　　　　　　1，项目，程序中都是程序员 new对象

　　　　　　　　　　（以前我们要自己new对象，现在spring帮我们new对象，以后我们需要对象，就找spring要）

　　　　　　　　　　以前：做鞋子手工做，效率低，每个细节都要关注

　　　　　　　　　　现在：工厂做，效率高，不需要关注每个细节

　　　　　　2，谁控制谁？

　　　　　　　　1，程序控制 new对象

　　　　　　3，反转什么？

　　　　　　　　1，程序员 new对象的权利反转给spring

　　2，aop

　　3，事物管理器

　　4，spring mvc&webFlux --最新的 mvc框架

5，spring中为什么叫bean工厂而不叫对象工厂？

　　1，对象----new类出来就是对象（女朋友，说换就换）

　　2，bean---具有生命周期的对象（媳妇，不能说换就换）

6，spring bean工厂

　　1，不适用bean工厂模式

　　　　面向对象的六大原则：开闭原则 系统/程序对修改关闭，对扩展开放

　　2，自己实现工厂----GOF23设计模式（单列模式，工厂模式）

　　　　1，自己阅读工厂模式材料学习

　　　　2，开闭原则：对修改关闭，对扩展开发

 　　　　　　　1、简单工厂 　　 1）不符合开闭原则 （反射） 　　2)要编写很多个工厂类 

　　　　　　　　 2、工厂方法模式

　　　　　　　　　3、抽象工厂

 

　　　　3，spring bean工厂 (本质ioc容器)
　　　　　　　　你想让bean工厂帮你new对象，首先要告诉spring bean工厂需要产生什么对象？　

　　　　1）导包
　　　　　　https://repo.spring.io/release/org/springframework/spring/

　　　　　　spring-beans-5.0.14.RELEASE.jar 支持bean工厂的包
　　　　　　spring-context-5.0.14.RELEASE.jar 支持context的包
　　　　　　spring-core-5.0.14.RELEASE.jar 支持spring的核心类的包
　　　　　　spring-expression-5.0.14.RELEASE.jar 支持spring表达式的包
　　　　　　spring-test-5.0.14.RELEASE.jar 支持spring单元测试

 

　　　　2）通过配置告诉spring bean工厂生产什么样的bean?
　　　　　　https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#spring-core
　　　　　　方式1：基于xml配置 （今天）
　　　　　　　　1）BeanFacotry 按需实例化
　　　　　　　　2) ApplicationContext 容器启动实例化所有的bean
　　　　　　　　ClassPathXmlApplicationContext
　　　　　　　　FileSystemXmlApplicationContext
　　　　　　注意：classpath:spring-beans.xml

　　　　　　WebApplicationContext 集成 mvc框架

例子：

//创建一个BlackPig类 继承Pig父类
public class BlackPig extends Pig{
    private int age;
    private String name;
    public BlackPig() {
        System.out.println("调用了BlackPig的构造方法");
    }
    public BlackPig(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "BlackPig [age=" + age + ", name=" + name + "]";
    }
  
}

　　

//创建一个pig类
public class Pig {

}

　　

//创建一个工厂
/*
 * 对象工厂还不能说是bean工厂
 * 
 * 
 */
public class ObjectFactory<T> {
    //不够优雅
//    public RedPig createRedpig() {
//        return new RedPig();
//    }
//    public BlackPig createBlackPig() {
//        return new BlackPig();
//    }
    
    
    /**
     * 稍微修改 多态：父引用指向任何子类对象
     * Pig p1 = new RedPig();
     * 
     * Pig p2 = new BlackPig();
     */
    
//    public Pig createPig(String type) {
//        if(type.equals("red")) {
//            return new RedPig();
//        }else if(type.equals("black")) {
//            return new BlackPig();
//        }else if(type.equals("blue")) {
//            return new BluePig();
//        }else if(type.equals("green")) {
//            return new GreenPig();
//        }else {
//            return null;
//        }
//    }
    //优雅的玩法 符合开闭原则的玩法 spring玩法
    public T createPig(Class clazz) {
        try {
            return (T) clazz.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
    
    
}

　　

//测试
public class Test {
    public static void main(String[] args) {
        //1.通过猪对象工厂获取黑猪或红猪对象
        ObjectFactory<Pig> factory = new ObjectFactory<Pig>();
        //获取黑猪
        Pig blackPig =factory.createPig(BlackPig.class);// (BlackPig) factory.createPig("black");//factory.createBlackPig();
        
        //获取狗，一样需要dog父类，和dog类
        ObjectFactory<Dog>  factory2 = new ObjectFactory<Dog>();
        Dog createPig = factory2.createPig(RedDog.class);
    }
}