Spring反转控制与依赖注入

Spring替代JDBC框架：MyBatis；
Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。

Spring框架

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，

• 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
• Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
• Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
• Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
• Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
• Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
• Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

Spring优点

• Spring是开源的，免费的
• Spring是一个轻量级的框架，非入侵式的框架
  • 没有任何其他的依赖，使用他，不需要导入其他的包

IOC

控制反转（inversion of Control）:IOC
反转：从被动到主动，程序员主动控制到被动接受，

利用Spring实现案例

1.导入jar包

org.springframework spring-webmvc 4.3.9.RELEASE **2.创建实体类**

package com.wang.pojo;

public class Hello {
    private String name;

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

    public Hello() {
    }

    public String getName() {
        return name;
    }

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

3.编写Spring的配置文件

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="hello" class="com.wang.pojo.Hello">
<property name="name" value="Spring"/>
    </bean>
</beans>

3.测试类

package com.wang.dao;

import com.wang.pojo.Hello;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void test(){
       ApplicationContext context=new  ClassPathXmlApplicationContext("Spring.xml");
        Hello hello = (Hello)context.getBean("hello");
        hello.show();
    }
}

输出结果：

通过上面的例子，可以看出程序本身不创建对象了，变成被动接受对象，这就是反转，
依赖注入：DI，本质就是利用set方式来注入的

package com.wang.pojo;

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

    public User() {
        System.out.println("无参构造了");
    }
    public User(String name,int age){
        this.name=name;
        this.age=age;
        System.out.println("有参构造2");
    }
    public User(String name){
        this.name=name;
        System.out.println("有参构造1");
    }

    public User(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        System.out.println("有参构造3");
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

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

配置文件
<?xml version="1.0" encoding="UTF-8"?>

    <bean id="user" class="com.wang.pojo.User">
        <property name="name" value="杜兰特"/>
    </bean>
    <bean id="user1"  class="com.wang.pojo.User">
        <property name="name" value="詹姆斯"/>
        <property name="age" value="30"/>
    </bean>
    <!--通过下标-->
    <bean id="user9" class="com.wang.pojo.User">
        <constructor-arg index="0" value="威少"/>
        <constructor-arg index="1" value="18"/>
    </bean>
    <!--通过类型-->
    <bean id="user2" class="com.wang.pojo.User">
        <property name="name" value="库里"/>
        <property name="age" value="36"/>
        <property name="sex" value="男"/>
    </bean>

    <bean id="user3" class="com.wang.pojo.User">
        <constructor-arg name="name" value="姚明"/>

    </bean>
<alias name="user4" alias="user7"/>
    <bean id="user4" class="com.wang.pojo.User">
        <constructor-arg name="name" value="欧文"/>
        <constructor-arg name="age" value="25"/>
    </bean>
        <!--通过名字-->
    <bean id="user5"   name="user6" class="com.wang.pojo.User">
        <constructor-arg name="name" value="乔治"/>
        <constructor-arg name="age" value="26"/>
        <constructor-arg name="sex" value="男"/>
    </bean>
</beans>

输出结果：

从结果看出,虽然你只调用了配置文件中的一个方法，它依然会初始化实体类的所有有参构造。
Spring配置文件
bean

<!--bean讲解：
1.没有id，没有name，我们依旧可以获取这个对象，但是不建议使用、需要使用类的class对象获取；
    User bean = context.getBean(User.class);

2.id 就是对象的名字
3.class 就是要实例化的类
4.name就是别名
    有id的时候，name是别名 ， 没有id的时候，name就是对象的名字
    别名可以起多个
-->
<bean id="user" name="userTwo,user3" class="com.kuang.pojo.User">
    <property name="name" value="Spring"/>
</bean>

alias

<!--alias讲解：
1. name ： 就是bean对象的id
2,alias ： 对象的别名
-->
<alias name="user" alias="user4"/>

import

<!--import讲解
作用：导入另外一个资源，把另外配置文件装进来
    classpath*: 他会去所有地方寻找你的文件。【效率低】
    classpath: 只会在classpath中寻找文件，找不到就报错；【建议使用】
    file：填写文件路径url【不建议使用】
    http：填写网络路径url【不建议使用】
-->
<import resource="classpath*:userBeans.xml"/>
<import resource="classpath:userBeans.xml"/>
<import resource="file:"/>
<import resource="http:"/>

依赖注入DI

DI（Dependcy Injection）
依赖：值bean对象的创建依赖于Spring容器，bean对象依赖的资源
注入：指Bean对象所依赖的资源，由容器；来设置和装配
构造器注入：

-有参
-无参
setter注入
要求被注入的属性，必须有set方法，set方法的名字需要规范set+属性名（属性名字母大写）

package com.wang.dao;

import java.util.*;

public class User {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobby;
    private Map<String,String > card;
    private Set<String >games;
    private String girlFriend;
    private Properties info;

    public User() {
    }

    public User(String name, Address address, String[] books, List<String> hobby, Map<String, String> card, Set<String> games, String girlFriend, Properties info) {

        this.name = name;
        this.address = address;
        this.books = books;
        this.hobby = hobby;
        this.card = card;
        this.games = games;
        this.girlFriend = girlFriend;
        this.info = info;
    }

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

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

    public String[] getBooks() {
        return books;
    }

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

    public List<String> getHobby() {
        return hobby;
    }

    public void setHobby(List<String> hobby) {
        this.hobby = hobby;
    }

    public Map<String, String> getCard() {
        return card;
    }

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

    public Set<String> getGames() {
        return games;
    }

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

    public String getGirlFriend() {
        return girlFriend;
    }

    public void setGirlFriend(String girlFriend) {
        this.girlFriend = girlFriend;
    }

    public Properties getInfo() {
        return info;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", address=" + address.toString() +
                ", books=" + Arrays.toString(books) +
                ", hobby=" + hobby +
                ", card=" + card +
                ", games=" + games +
                ", girlFriend='" + girlFriend + '\'' +
                ", info=" + info +
                '}';
    }
}

注入

<?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="add" class="com.wang.dao.Address">
    <property name="name" value="西安"/>
</bean>

    <bean id="student" class="com.wang.dao.User">
        <property name="name" value="小花"/>

        <property name="books">
            <array>
                <value>西游记</value>
                <value>红楼梦</value>
                <value>三国</value>
                <value>水浒传</value>
            </array>
        </property>
        <property name="address" ref="add"></property>
        <property name="card">
            <map>
                <entry key="IdCard" value="567868688"/>
                <entry key="StCard" value="787979"/>
            </map>
        </property>
        <property name="games">
            <set>
                <value>王者荣耀</value>
                <value>吃鸡</value>
            </set>
        </property>
        <property name="girlFriend">
            <null></null>
        </property>
        <property name="hobby">
            <list>
                <value>唱</value>
                <value>跳</value>
                <value>rap</value>
            </list>
        </property>
        
        <property name="info">
            <props>
                <prop key="1">学号</prop>
                <prop key="性别">男</prop>
                <prop key="年龄">23</prop>
            </props>
        </property>
    </bean>
</beans>

p命名空间注入
c命名空间注入
注意：需要导入对应的约束文件
属性的注入：

<?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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">


   <bean id="user1" class="com.wang.pojo.User" p:name="xiaohu" p:age="23"/>
<bean id="user2" class="com.wang.pojo.User" c:name="hdjhj" c:age="34"/>

</beans>

自动装配
byName：根据setter方法名进行自动装配，Spring容器查找容器中全部的 bean，查出其id与set后名字相同的，如果没有找到匹配的Bean，则什么都不会发生，setter方法也不会调用。
byType：根据类型自动装配.Spring 容器查找容器中全部的Bean,如果正好有一个Bean类型与setter方法的方法的形参类型匹配，就自动注入这个Bean.如果找到多个这样的Bean,就会抛出一个异常。如果没有找到匹配的Bean,则什么都不会发生，setter方法也不会被调用。

<bean id="myRole" class="com.wang.dao.Role" p:id="101" p:name="管理员"/>

<!--自动装配，不建议使用，建议使用注解-->
<bean id="user" class="com.wang.dao.User" autowire="byName"/>