Spring框架学习笔记1-IOC

我就是我 2022-11-12 01:43 181阅读 0赞

## 一、Spring概述 ##

## 1.1、Spring框架概述： ##

> Spring框架 是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情
> 
> 目的：  
> （1）使用接口而不是使用类，是更好的编程习惯  
> （2）为JavaBean提供了一个更好的应用配置框架。  
> 核心部分：IOC 和 AOP  
> IOC（Inversion of Control，即控制反转）：把对象创建和对象之间的调用过程，交给Spring进行管理，以此降低代码之间的耦合度；  
> AOP（Aspect Oriented Programming，即面向切面）：通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

## 二、IOC（Inversion of Control，控制反转） ##

1.  什么IOC：把对象创建和对象之间的调用过程，交给Spring进行管理，以此降低代码之间的耦合度；
2.  IOC底层原理：xml解析，工厂模式，反射；
3.  Spring实现IOC的两种方式（两个接口）：  
    a）BeanFactory接口：IOC容器基本实现是Spring内部接口的使用接口，不提供给开发人员进行使用（加载配置文件时候不会创建对象，在获取对象时才会创建对象。） ；  
    b）ApplicationContext接口：BeanFactory接口的子接口，提供更多更强大的功能，提供给开发人员使用（加载配置文件时候就会把在配置文件对象进行创建），常使用该接口进行开发；

> ApplicationContext的主要实现类：
> 
> ClassPathXmlApplicationContext：对应类路径下的XML格式的配置文件  
> FileSystemXmlApplicationContext：对应文件系统中的XML格式的配置文件

## 三、IOC容器-Bean管理（xml解析方式） ##

## 3.1、Bean管理xml解析方式的多种方法 ##

**1. 首先要配置xml相关内容：**

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    	
    </beans>

**2. 需要导入的Jar包：**  
![在这里插入图片描述][2021032120491919.png]

**3. Bean管理-创建对象和set注入属性（默认无参构造方法创建对象）**

User相关类：

public class User {
        
    
        public void add(){
        
            System.out.println("调用User对象add方法...");
        }
    }

xml配置文件：

测试类：

public class testspring5 {
        
        @Test
        public  void testadd(){
        
            ApplicationContext context=new ClassPathXmlApplicationContext("com/atguigu/spring/bean1.xml");
            User user=context.getBean("user", User.class);
            System.out.println(user);
            user.add();
        }
    }

输出结果：  
![在这里插入图片描述][20210321205230245.png]

**4. Bean管理-有参构造方法注入属性：**

public class User {
        
    
        String name;
        String id;
    
        public User(String name,String id){
        
            this.name=name;
            this.id=id;
        }
    
        public void display(){
        
            System.out.println("id:"+id+"\tname:"+name);
        }
    }

测试输出结果：  
![在这里插入图片描述][20210321205807964.png]

**5. Bean管理-注入空值或特殊符号：**

public class User {
        
    
        String name;
        String id;
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public void setId(String id) {
        
            this.id = id;
        }
    
        public User(){
        
        }
    
        public void display(){
        
            System.out.println("id:"+id+"\tname:"+name);
        }
    }

<bean id="user" class="com.atguigu.spring.User">
            
            <property name="name">
                <value><![CDATA[<<测试>>]]></value>
            </property>
    
            
            <property name="id" >
                <null/>
            </property>
        </bean>

测试结果：  
![在这里插入图片描述][20210321210837455.png]

**6. Bean管理-注入外部bean**

User类中引入Book类对象作为属性：

public class User {
        
    
        String name;
        String id;
        Book book;
        public void setName(String name) {
        
            this.name = name;
        }
    
        public void setId(String id) {
        
            this.id = id;
        }
    
        public void setBook(Book book) {
        
            this.book = book;
        }
    
        public User(){
        
        }
    
        public void display(){
        
            System.out.println("id:"+id+"\tname:"+name+"\tbookname:"+book.bookName);
        }
    }

Book类：

public class Book {
        
    
        String bookName;
        String bookNo;
    
        public void setBookName(String bookName) {
        
            this.bookName = bookName;
        }
    
        public void setBookNo(String bookNo) {
        
            this.bookNo = bookNo;
        }
    }

采用外部注入的方式进行bean管理：

![在这里插入图片描述][20210321212048121.png]

**7. Bean管理-内部bean和级联赋值**

java类如上部分，xml部分进行修改如下：

<bean id="user" class="com.atguigu.spring.User">
            <property name="name" value="Username"></property>
            <property name="id"  value="Userid"></property>
            <property name="book">
                <bean id="book" class="com.atguigu.spring.Book">
                    <property name="bookName" value="bookname"></property>
                </bean>
            </property>
        </bean>

<bean id="user" class="com.atguigu.spring.User">
            <property name="name" value="Username"></property>
            <property name="id"  value="Userid"></property>
            <property name="book" ref="book"></property>
            <property name="book.bookName" value="bookname"></property>
        </bean>
        <bean id="book" class="com.atguigu.spring.Book"></bean>

**8. Bean管理-注入集合类型属性**

public class User {
        
        String []arrays;
        List<String> list;
        Map<String,String> map;
        public void setMap(Map<String, String> map) {
        
            this.map = map;
        }
        public void setList(List<String> list) {
        
            this.list = list;
        }
        public void setArrays(String[] arrays) {
        
            this.arrays = arrays;
        }
        public void display(){
        
            System.out.println(arrays);
            System.out.println(list);
            System.out.println(map);
        }
    }

<bean id="user" class="com.atguigu.spring.User">
            <property name="arrays">
                <array>
                    <value>数据结构</value>
                    <value>数据库</value>
                    <value>操作系统</value>
                </array>
            </property>
    
            <property name="list">
                <list>
                    <value>list数据库</value>
                    <value>list数据结构</value>
                    <value>list操作系统</value>
                </list>
            </property>
    
            <property name="map">
                <map>
                    <entry key="課程一" value="數據結構"></entry>
                    <entry key="課程二" value="數據庫"></entry>
                </map>
            </property>
        </bean>

## 3.2、IOC操作Bean管理 ##

**1、IOC操作Bean管理（Factory）**

> 1、Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）  
> 2、普通 bean：在配置文件中定义 bean 类型就是返回类型 （以上实现的多种类型）  
> 3、工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样 第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean 第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型

实例：

public class User {
        
        String name;
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public void display(){
        
            System.out.println(name);
        }
    }

import org.springframework.beans.factory.FactoryBean;
    
    public class mybean implements FactoryBean<User> {
        
    
        @Override
        public User getObject() throws Exception {
        
            User user=new User();
            user.setName("Abc");
            return user;
        }
    
        @Override
        public Class<?> getObjectType() {
        
            return null;
        }
    
    
    }

输出结果：  
![在这里插入图片描述][20210323203951560.png]

> FactoryBean 接口中有如下三个方法，getObject() 方法负责将创建好的 bean 实例返回给 IOC 容器；getObjectType() 方法负责返回工厂生产的 bean 类型；isSingleton() 方法用于指示该 bean 实例是否为单例，默认是单例 bean.

**2、Bean的作用域**

1）. 在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例；  
2）. scope 属性值 第一个值 默认值，singleton，表示是单实例对象 第二个值 prototype，表示是多实例对象。

**3、bean的生命周期**

> 1、生命周期 ：从对象创建到对象销毁的过程  
> 2、bean 生命周期  
> （1）通过构造器创建 bean 实例（无参数构造）  
> （2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）  
> （3）调用 bean 的初始化的方法（需要进行配置初始化的方法）  
> （4）bean 可以使用了（对象获取到了）  
> （5）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

## 四、IOC容器-Bean管理（注解方式） ##

**1、什么是注解？**

> （1）注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值…)
> 
> （2）使用注解，注解作用在类上面，方法上面，属性上面
> 
> （3）使用注解目的：简化 xml 配置

**2、Spring为Bean管理提供创建对象的注解**

> ①普通组件：@Component，用于标识一个受Spring IOC容器管理的组件  
> ②持久化层组件：@Respository，用于标识一个受Spring IOC容器管理的持久化层组件  
> ③业务逻辑层组件：@Service，用于标识一个受Spring IOC容器管理的业务逻辑层组件  
> ④表述层控制器组件：@Controller，用于标识一个受Spring IOC容器管理的表述层控制器组件

注意：事实上Spring并没有能力识别一个组件到底是不是它所标记的类型，即使将@Respository注解用在一个表述层控制器组件上面也不会产生任何错误，所以@Respository、@Service、@Controller这几个注解仅仅是为了让开发人员自己明确当前的组件扮演的角色。

**3、基于注解方式实现对象创建**

*  引入相应的jar包（spring-aop.jar）  
    ![在这里插入图片描述][20210323211318861.png]
 *  引入contex的命名空间

*  开启组件扫描（bean文件中加入下列语句）

<context:component-scan base-package="com.atguigu.spring"></context:component-scan>

\-类的上方加上相应注解  
![在这里插入图片描述][20210323211825447.png]

*  测试结果：创建成功  
    ![在这里插入图片描述][20210323211850814.png]

**4、基于注解方式实现属性注入**

> （1）@Autowired：根据属性类型进行自动装配  
> （2）@Qualifier：根据名称进行注入，这个@Qualifier  
> 注解的使用，和上面@Autowired 一起使用  
> （3）@Resource：可以根据类型注入，也可以根据名称注入（它属于javax包下的注解，不推荐使用！）  
> （4）@Value：注入普通类型属性

[2021032120491919.png]: /images/20221022/ba230b01580f48e8bb042298147de3fa.png
[20210321205230245.png]: https://img-blog.csdnimg.cn/20210321205230245.png
[20210321205807964.png]: https://img-blog.csdnimg.cn/20210321205807964.png
[20210321210837455.png]: https://img-blog.csdnimg.cn/20210321210837455.png
[20210321212048121.png]: https://img-blog.csdnimg.cn/20210321212048121.png
[20210323203951560.png]: https://img-blog.csdnimg.cn/20210323203951560.png
[20210323211318861.png]: https://img-blog.csdnimg.cn/20210323211318861.png
[20210323211825447.png]: https://img-blog.csdnimg.cn/20210323211825447.png
[20210323211850814.png]: https://img-blog.csdnimg.cn/20210323211850814.png