Spring 控制反转（IOC）基础知识01

Spring 概述

理念：使现有技术更加实用，本身就是一个大杂烩，整合现有的框架技术，是一个轻量级的控制反转和面向切面编程的框架。
官网：spring官网
优点：

1. Spring是一个开源免费的框架
2. Spring是一个轻量级的框架，非入侵式的
3. 控制反转IOC,面向切面AOP
4. 对事物的支持，对框架的支持

组成结构：
Spring框架是一个分层架构，由7个定义良好的模块组成。Spring模块构建在核心容器上，核心容器定义了创建，配置，管理Bean的方式。
Spring Core：提供Spring框架基本功能。主要主件是BeanFactory，是工厂模式的实现类。

Spring Context:Spring 是一个配置文件，向Spring框架提供上下文信息。

Spring AOP:通过配置管理特性，直接面向切面的编程功能，集成到Spring框架中，所以可以很容易的支持任何AOP对象，提供事务管理服务，不用依赖组件。

SpringDao:面向JDBC的异常遵从通用的Dao异常层次结构。

Spring ORM:包括JDO Hibernate,ibatis SqlMap，都遵循Spring通用事务和Dao 异常层次结构。

SpringWeb:简化了处理多部分人请求，以及将请求参数绑定到域对象的工作

SpringMVC框架:MVC容纳了大量视图技术，其中包括JSP Velocity Tiles iText Pol

IOC基础

IOC作为Spring两大重要特点之一，是我们必须要掌握的，控制反转是一种设计思想，DI（依赖注入）是实现IOC的一种方法。在普通程序中，我们使用的是面向对象编程，对象的创建与对象之间的依赖完全由程序控制，控制反转就是将对象的创建转移到第三方。通过IOC，程序可以一步步达到以下理想状态：

实现IOC:

1.导入相关依赖：

 <dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.7.RELEASE</version>
        <type>pom</type>
    </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>
    </dependencies>

2.编写一个实体类：
包括一个Person类，属性为名字，以及set和get等方法

public class Person {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

3.编写DAO层和其实现类：

public interface UserDao {
    public void getUser();
}

public class UserDaoImpl implements UserDao{
    public void getUser() {
        System.out.println("以进入UserDaoImpl");
    }
}

public class RoleDaoImpl implements UserDao {
    public void getUser() {
        System.out.println("已进入RoleDaoImpl");
    }
}

4.编写Service层和实现类

public interface UserService {
    public void getUser();
}

public class UserServiceImpl implements UserService{
    private UserDao userDao;
  public void setUserDao(UserDao userDao){
      this.userDao=userDao;
  }
    public void getUser() {
        userDao.getUser();
    }
}

setUserDao（）方法为实现控制反转的关键所在。

5.编写beans.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="person" class="pojo.Person">
    <property name="name" value="张三"/>
</bean>

<bean id="user" class="dao.UserDaoImpl"/>
    <bean id="role" class="dao.RoleDaoImpl"/>

    <bean id="userService" class="service.UserServiceImpl">
        <property name="userDao" ref="user"/>
    </bean>

</beans>

bean就是java对象，由spring创建管理，这样的话，再多次添加UserDao的实现类时，就只需要在xml文件中创建管理就行。此外，ref表示引用，大部分是通过引入类来决定值。

6.编写测试类：
测试一：打印出person类属性内容

public class MyTest{
  public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Person p = (Person) context.getBean("person");
        p.toString();
        System.out.println(p);
    }
        }

结果：
解释说明：在代码中，我们并没有new出任何对象，但是可以打印出属性内容，这是由spring创建的，更细一点，是在xml文件中的bean中设置的。这个过程就叫做控制反转。并且值得注意的是，在配置文件加载的时候，Person对象就已经初始化了。
控制的含义：传统程序中，对象由程序本身创建，（new 关键字）使用spring后，对象有上述过程创建。
反转的含义：程序本身不创建对象，而变成被动的接收对象。

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

测试二：调用dao事务

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
        UserServiceImpl service = (UserServiceImpl) context.getBean("userService");
        service.getUser();
    }
}

结果：
解释说明：在UserServiceImpl中添加了set方法后，就可以在最后的测试类中，context.getBean（）方法中设置需要传入的参数，也就是实现了非程序创建，由自己创建管理。现在，我们彻底不用再程序中改动了，只需要在xml文件中进行添加或者修改，所谓的IOC，浓缩成一句话就是：对象由spring容器创建，管理，控制。

Spring配置

1.别名
alias设置别名，为bean设置别名，可以设置多个别名

<!--设置别名：在获取Bean的时候可以使用别名获取-->
<alias name="userT" alias="userNew"/>

2.Bean的配置

<!--bean就是java对象,由Spring创建和管理-->

<!--
   id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
   如果配置id,又配置了name,那么name是别名
   name可以设置多个别名,可以用逗号,分号,空格隔开
   如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;

class是bean的全限定名=包名+类名
-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

以上为Spring的入门知识和IOC的基础应用。