官网：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框架
例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
//创建一个BlackPig类 继承Pig父类<br data-filtered="filtered">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 + "]"; } } |
|
1
2
3
4
|
//创建一个pig类public class Pig {} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
//创建一个工厂/* * 对象工厂还不能说是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; } } |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
//测试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); }} |
来源：https://www.cnblogs.com/qxhIndex/p/14131640.html
