Spring-IOC&&Spring-DI

SH TOO IS

于 2021-04-14 22:33:52 发布

阅读量54

点赞数

原文链接：3de.com

版权

HelloSpring
导入Jar包

注 : spring 需要导入commons-logging进行日志记录 . 我们利用maven , 他会自动下载对应的依赖项 .

org.springframework spring-webmvc 5.1.10.RELEASE 编写代码

1、编写一个Hello实体类

public class Hello {
private String name;

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

public void show(){
    System.out.println("Hello,"+ name );
}

}
2、编写我们的spring文件 , 这里我们命名为beans.xml

<?xml version="1.0" encoding="UTF-8"?>

<!--bean就是java对象 , 由Spring创建和管理-->
<bean id="hello" class="com.kuang.pojo.Hello">
    <property name="name" value="Spring"/>
</bean>

3、我们可以去进行测试了 .

@Test
public void test(){
//解析beans.xml文件 , 生成管理相应的Bean对象
ApplicationContext context = new ClassPathXmlApplicationContext(“beans.xml”);
//getBean : 参数即为spring配置文件中bean的id .
Hello hello = (Hello) context.getBean(“hello”);
hello.show();
}
思考

Hello 对象是谁创建的 ? 【hello 对象是由Spring创建的

Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的

这个过程就叫控制反转 :

控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的

反转 : 程序本身不创建对象 , 而变成被动的接收对象 .

依赖注入 : 就是利用set方法来进行注入的.

IOC是一种编程思想，由主动的编程变成被动的接收

可以通过newClassPathXmlApplicationContext去浏览一下底层源码 .

修改案例一

我们在案例一中，新增一个Spring配置文件beans.xml

<?xml version="1.0" encoding="UTF-8"?>

<bean id="MysqlImpl" class="com.kuang.dao.impl.UserDaoMySqlImpl"/>
<bean id="OracleImpl" class="com.kuang.dao.impl.UserDaoOracleImpl"/>
<bean id="ServiceImpl" class="com.kuang.service.impl.UserServiceImpl">
    <!--注意: 这里的name并不是属性 , 而是set方法后面的那部分 , 首字母小写-->
    <!--引用另外一个bean , 不是用value 而是用 ref-->
    <property name="userDao" ref="OracleImpl"/>
</bean>

测试！

@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext(“beans.xml”);
UserServiceImpl serviceImpl = (UserServiceImpl) context.getBean(“ServiceImpl”);
serviceImpl.getUser();
}
OK , 到了现在 , 我们彻底不用再程序中去改动了 , 要实现不同的操作 , 只需要在xml配置文件中进行修改 , 所谓的IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配 !

IOC创建对象方式
通过无参构造方法来创建

1、User.java

public class User {

private String name;

public User() {
    System.out.println("user无参构造方法");
}

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

public void show(){
    System.out.println("name="+ name );
}

}
2、beans.xml

<?xml version="1.0" encoding="UTF-8"?>

<bean id="user" class="com.kuang.pojo.User">
    <property name="name" value="kuangshen"/>
</bean>

3、测试类

@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext(“beans.xml”);
//在执行getBean的时候, user已经创建好了 , 通过无参构造
User user = (User) context.getBean(“user”);
//调用对象的方法 .
user.show();
}
结果可以发现，在调用show方法之前，User对象已经通过无参构造初始化了！

通过有参构造方法来创建

1、UserT . java

public class UserT {

private String name;

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

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

public void show(){
    System.out.println("name="+ name );
}

}
2、beans.xml 有三种方式编写

3、测试

@Test
public void testT(){
ApplicationContext context = new ClassPathXmlApplicationContext(“beans.xml”);
UserT user = (UserT) context.getBean(“userT”);
user.show();
}
结论：在配置文件加载的时候。其中管理的对象都已经初始化了！

Spring配置
别名

alias 设置别名 , 为bean设置别名 , 可以设置多个别名

Bean的配置 import

团队的合作通过import来实现 .

Dependency Injection

概念

依赖注入（Dependency Injection,DI）。

依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 .

注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 .

构造器注入

我们在之前的案例已经讲过了

Set 注入（重点）

要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is .

测试pojo类 :

Address.java

public class Address {

 private String address;

 public String getAddress() {
     return address;
 }

 public void setAddress(String address) {
     this.address = address;
 }

}
Student.java

package com.kuang.pojo;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class Student {

 private String name;
 private Address address;
 private String[] books;
 private List<String> hobbys;
 private Map<String,String> card;
 private Set<String> games;
 private String wife;
 private Properties info;

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

 public void setAddress(Address address) {
     this.address = address;
 }

 public void setBooks(String[] books) {
     this.books = books;
 }

 public void setHobbys(List<String> hobbys) {
     this.hobbys = hobbys;
 }

 public void setCard(Map<String, String> card) {
     this.card = card;
 }

 public void setGames(Set<String> games) {
     this.games = games;
 }

 public void setWife(String wife) {
     this.wife = wife;
 }

 public void setInfo(Properties info) {
     this.info = info;
 }

 public void show(){
     System.out.println("name="+ name
             + ",address="+ address.getAddress()
             + ",books="
     );
     for (String book:books){
         System.out.print("<<"+book+">>\t");
     }
     System.out.println("\n爱好:"+hobbys);

     System.out.println("card:"+card);

     System.out.println("games:"+games);

     System.out.println("wife:"+wife);

     System.out.println("info:"+info);

 }

}
1、常量注入

测试：

@Test
public void test01(){
ApplicationContext context = new ClassPathXmlApplicationContext(“applicationContext.xml”);

 Student student = (Student) context.getBean("student");

 System.out.println(student.getName());

}
2、Bean注入

注意点：这里的值是一个引用，ref

3、数组注入西游记红楼梦水浒传 4、List注入听歌看电影爬山 5、Map注入 6、set注入 LOL BOB COC 7、Null注入

8、Properties注入

20190604 男小明测试结果：

p命名和c命名注入

User.java ：【注意：这里没有有参构造器！】

public class User {
private String name;
private int age;

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

 public void setAge(int age) {
     this.age = age;
 }

 @Override
 public String toString() {
     return "User{" +
             "name='" + name + '\'' +
             ", age=" + age +
             '}';
 }

}
1、P命名空间注入 : 需要在头文件中加入约束文件

导入约束 : xmlns:p=“http://www.springframework.org/schema/p”

2、c 命名空间注入 : 需要在头文件中加入约束文件

导入约束 : xmlns:c=“http://www.springframework.org/schema/c”

发现问题：爆红了，刚才我们没有写有参构造！

解决：把有参构造器加上，这里也能知道，c 就是所谓的构造器注入！

测试代码：

@Test
public void test02(){
ApplicationContext context = new ClassPathXmlApplicationContext(“applicationContext.xml”);
User user = (User) context.getBean(“user”);
System.out.println(user);
}
Bean的作用域

在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为bean。简单地讲，bean就是由IoC容器初始化、装配及管理的对象 .

几种作用域中，request、session作用域仅在基于web的应用中使用（不必关心你所采用的是什么web应用框架），只能用在基于web的Spring ApplicationContext环境。

Singleton

当一个bean的作用域为Singleton，那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。Singleton是单例类型，就是在创建起容器时就同时自动创建了一个bean的对象，不管你是否使用，他都存在了，每次获取到的对象都是同一个对象。注意，Singleton作用域是Spring中的缺省作用域。要在XML中将bean定义成singleton，可以这样配置：

测试：

@Test
public void test03(){
ApplicationContext context = new ClassPathXmlApplicationContext(“applicationContext.xml”);
User user = (User) context.getBean(“user”);
User user2 = (User) context.getBean(“user”);
System.out.println(user==user2);
}
Prototype

当一个bean的作用域为Prototype，表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。Prototype是原型类型，它在我们创建容器的时候并没有实例化，而是当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。根据经验，对有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。在XML中将bean定义成prototype，可以这样配置：

或者 Request

当一个bean的作用域为Request，表示在一次HTTP请求中，一个bean定义对应一个实例；即每个HTTP请求都会有各自的bean实例，它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

<bean id=“loginAction” class=cn.csdn.LoginAction" scope=“request”/>
针对每次HTTP请求，Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实例，且该loginAction bean实例仅在当前HTTP request内有效，因此可以根据需要放心的更改所建实例的内部状态，而其他请求中根据loginAction bean定义创建的实例，将不会看到这些特定于某个请求的状态变化。当处理请求结束，request作用域的bean实例将被销毁。

Session

当一个bean的作用域为Session，表示在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

针对某个HTTP Session，Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例，且该userPreferences bean仅在当前HTTP Session内有效。与request作用域一样，可以根据需要放心的更改所创建实例的内部状态，而别的HTTP Session中根据userPreferences创建的实例，将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候，在该HTTP Session作用域内的bean也会被废弃掉。 71