今天学习了spring框架，刚刚入门简单的了解了spring并学习了bean的注入IOC:IOC(Inversion of Control，控制反转)不是什么技术，而是一种设计思想。它的目的是指导我们设计出更加松耦合的程序。
引入：
使用简单代码来实现推演 ，创建一个maven项目，开始我们的推演
创建一个bean类即常说的实体类如下：
我们创建一个测试类 springTest，在测试类中操作，怎么样来获取Student类中 的信息呢（student类中有构造方法，无参，有参，有get，set方法，有studay() 方法 等等）
我们要怎么样来获取对象呢：
1.直接获取：
@Test
public void springTest() {
Student student = new Student();
student.getStudy();
/*
* 输出 学生在学习
* */
}
上述代码是否显得太low了，因为假若有n个类使用这个对像，我们要在每一个类中new，假若你要修改，这样的一个工程量会有点大。
2.工具类获取：
我们创建工具类来减少耦合性，在修改维护时只要修改工具类就行 代码调用：
@Test
public void springTest02() {
Student stu = StudentBean.getStu();
stu.getStudy();
/*
* 输出 学生在学习
* */
}
这样就减少了一定的耦合性能，但在实际运用中，我们只可能只有一个实体类嘛当然不可能，如何提升性能并减少代码的耦合性呢
我们采用配置文件的方法建一个 beans.properties 存放bean的配置文件，并多创建一个实体类user
重新再创建一个工具类BeanFactroy来编写我们的最终代码：
public class BeanFactory {
// 创建map集合存储对象
private static Map<String, Object> beanMap = new HashMap<String, Object>();
/*
* 在类初始化时读取beans配置文件中所有的bean类存储到map集合中
* */
static {
try {
ResourceBundle beans = ResourceBundle.getBundle("beans");// 读取beans配置文件
Enumeration<String> keys = beans.getKeys(); // 获取所有key值
while (keys.hasMoreElements()) {
String key = keys.nextElement(); // 获取每个key
String className = beans.getString(key); // 获取value
Class<?> aClass = Class.forName(className); // 通过反射得到该类
Object o = aClass.newInstance(); // 通过反射机制创建该类对象
beanMap.put(key, o); // 将k v值存入beanMap集合中
}
} catch (Exception e) {
e.printStackTrace();
}
}
/* 创建静态方法供外界调用
* */
public static Object getBean(String beanName) {
return beanMap.get(beanName);
}
}
上面是工具类，下面是测试：
@Test
public void springTest03() {
User user = (User) BeanFactory.getBean("user");
user.getStudy();
/*
* 输出 我在学习
* */
}
@Test
public void springTest04() {
Student stu = (Student) BeanFactory.getBean("student");
stu.getStudy();
/*
* 输出 学生在学习
* */
}
上面的实例简单的展示来如何减少耦合性，最终下来，在管理对象时，我们只需要修改beans.properties 文件即可，更加方便管理下面进入spring的ioc容器使用
Bean容器注入：
第一步导包：
<properties>
<spring.version>5.2.9.RELEASE</spring.version>
<junit-version>5.6.2</junit-version>
</properties> <dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency> <dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>${junit-version}</version>
</dependency>
</dependencies>
第二步创建配置文件 applicationContext.xml （认准下面的步骤）
完成后如下：
开始编写：
通过构造方法获取对象：
测试代码：
/*
* 读取app.xml文件 抽取出来
* */
private ApplicationContext ac = new ClassPathXmlApplicationContext("app.xml"); @Test
public void springTest05() {
User user1 = (User) ac.getBean("user1"); // user1与app.xml中bean里面的id值相对应
user1.getStudy();
// 打印 我在学习
}
读取xml方法：
- ClassPathXmlApplicationContext: 从classpath目录读取配置文件
- FileSystemXmlApplicationContext: 从文件系统或者url中读取配置文件
- AnnotationConfigApplicationContext：当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器，它用来读取注解。
使用前面的工厂来获取对象：
测试代码：
@Test
public void springTest06() {
User user1 = (User) ac.getBean("user2"); // user1与app.xml中bean里面的id值相对应
user1.getStudy();
// 打印 我在学习
}
在操作这里的时候我将BeanFactory修改了一点：
public class BeanFactory {
private String beanName;
private static Map<String, Object> beansObjectHashMap = new HashMap<String, Object>();
public BeanFactory() {
}
public BeanFactory(String beanName) {
this.beanName = beanName;
}
/*
* 采用静态代码块，在程序开始时，就将所有的对象存在beansObjectHashMap map集合中，使用时直接调用
* */
static {
try {
ResourceBundle beans = ResourceBundle.getBundle("beans");
Enumeration<String> keys = beans.getKeys();
while (keys.hasMoreElements()) {
String key = keys.nextElement();
String className = beans.getString(key);
Class<?> aClass = Class.forName(className);
Object o = aClass.newInstance();
beansObjectHashMap.put(key, o);
}
} catch (Exception e) {
e.printStackTrace();
}
}
// 采用配置文件获取对象 只能 获取一个
public static Object getBeanUser(String beanName) {
try {
ResourceBundle bundle = ResourceBundle.getBundle("beans");
String string = bundle.getString(beanName);
Class<?> aClass = Class.forName(string);
Object o = aClass.newInstance();
return o;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/*
* 当有多个实体类时 封装一个map集合返回
* */
public static Object getBeanMap(String beanName) {
return beansObjectHashMap.get(beanName);
}
/* public Object getBeanMap() {
return beansObjectHashMap.get(this.beanName);
}*/
}
Bean单例与多例：
<!--
Bean单例与多例，在bean容器中添加有个scope属性，singleton代表单例
prototype 代表多例，单例获取的对象地址值是相同的，多例是不同的
调用案例就一样的不写了
-->
<bean id="user3" class="com.code.spring01.entity.User" scope="singleton"></bean> <!-- 单例 -->
<bean id="user4" class="com.code.spring01.entity.User" scope="prototype"></bean> <!-- 多例 -->
<!--
单例生命周期：容器创建时，就创建对象；容器摧毁时，就摧毁对象。
多例生命周期：getBean方法被调用时，创建对象，对象销毁与spring无关，等待垃圾回收机制回收
-->
set方法注入：
<!--
使用set注入时，bean类中需存在get set 方法
set 方法注入 property和constructor-arg 使用时的区别
（不用在意顺序）property注入时可以单个属性的注入，即想写几个属性就写几个（不能超过）
constructor-arg 注入时，需全部属性都注入，否则会报错
-->
<bean id="stu2" class="com.code.spring01.entity.Student">
<property name="age" value="19"></property>
<property name="name" value="张三"></property>
</bean>
<!-- <bean id="stu2" class="com.code.spring01.entity.Student">
<constructor-arg name="name" value="张三"></constructor-arg>
</bean>-->
<!--
set 注入的简写 方式
-->
<bean id="stu3" class="com.code.spring01.entity.Student" p:name="王五" p:pwd="123" p:age="31" p:sex="男"/>
集合属性注入：
实体类：
public class Tec {
// 基本属性
private Integer id;
private String username;
private String password;
private Address address;
//list set array
private String[] str;
private List<String> list;
private Set<String> set;
//map properties
private Map<String,String> map;
private Properties properties;
// 省略了set方法
bean注入：
<bean id="user" class="com.hopu.ioc.User">
<property name="str">
<array>
<value>EE</value>
<value>FF</value>
</array>
</property>
<property name="list">
<list>
<value>AA</value>
<value>BB</value>
</list>
</property>
<property name="set">
<set>
<value>CC</value>
<value>DD</value>
</set>
</property> <property name="map">
<map>
<entry key="GG" value="gg"/>
<entry key="HH" value="hh"/>
</map>
</property>
<property name="properties">
<props>
<prop key="II">ii</prop>
<prop key="JJ">jj</prop>
</props>
</property>
</bean>
Bean的多模块注入：
当项目过于庞大时，为了开发便于维护和可读性，我们可以将bean配置文件模块化，采用导入模块方式优化管理
<!--
在app.xml中导入app2.xml文件
-->
<import resource="app2.xml"/>
注解注入：
这个我没学，在百度上看了，简单模仿这操作一番：
@Component("admin") // 等同于bean id="admin" class="com.code.spring01.entity.Admin"></bean>
@Scope(scopeName = "singleton") // 限制创建的为单例对象
//@Scope(scopeName = "prototype") // 限制创建的为多例对象
public class Admin {
private String name;
private String color;
public Admin(String name, String color) {
this.name = name;
this.color = color;
}
public Admin() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return color;
}
public void setAge(String color) {
this.color = color;
}
@Override
public String toString() {
return "Admin{" +
"name='" + name + '\'' +
", color='" + color + '\'' +
'}';
}
}
私有成员变量注入：
@Value("BMW")
private String name;
@Value("Red")
private String color;
set方法注入：
@Value("BMW")
public void setName(String name) {
this.name = name;
}
@Value("Red")
public void setColor(String color) {
this.color = color;
}
在使用时当然是bean容器更加方便管理一些，代码耦合性也低
个人学习，内容简略。