Spring学习（一）

1.Spring的简介

• Spring是一个开源的轻量级，具有控制反转（IoC）和面向切面编程（AOP）的Java 开发框架。
• Java Spring 框架通过声明式方式灵活地进行事务的管理，提高开发效率和质量。
• Spring 框架不仅限于服务器端的开发。
• 从简单性、可测试性和松耦合的角度而言，任何 Java 应用都可以从 Spring 中受益。

Spring的优点

1. 方便解耦，简化开发
   Spring 就是一个大工厂，可以将所有对象的创建和依赖关系的维护交给 Spring 管理。
2. 方便集成各种优秀框架
   Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架的直接支持。
3. 降低 Java EE API 的使用难度
   Spring 对 Java EE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等）都提供了封装，使这些 API 应用的难度大大降低。
4. 方便程序的测试
   Spring 支持 JUnit4，可以通过注解方便地测试 Spring 程序。
5. AOP 编程的支持
   Spring 提供面向切面编程，可以方便地实现对程序进行权限拦截和运行监控等功能。
6. 声明式事务的支持
   只需要通过配置就可以完成对事务的管理，而无须手动编程。

2.控制反转（IOC）

IoC 是指在程序开发中，实例的创建不再由调用者管理，而是由 Spring 容器创建。Spring 容器会负责控制程序之间的关系，而不是由程序代码直接控制，因此，控制权由程序代码转移到了 Spring 容器中，控制权发生了反转，这就是 Spring 的 IoC 思想。
所谓IoC，就是对象由Spring进行创建，管理，配置。

实例：

1.创建maven工程，导入 spring 的依赖

<dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
    </dependencies>

2.创建接口和类

package com.chen.Dao;
public interface UserDao {
    void getUser();
}

package com.chen.Dao;
public class UserDaoImp implements UserDao{
    public void getUser() {
        System.out.println("进入dao层");
    }
}

package com.chen.Dao;

public class MysqlDaoImp implements UserDao{

    public void getUser() {
        System.out.println("mysql进入");
    }
}

package com.chen.Dao;
public class OrcalDaoImp implements UserDao{

    private  String str;
    public void setStr(String str) {
        this.str = str;
    }

    public void getUser() {
        System.out.println(str);
        System.out.println("orcal进入");
    }
}

3.配置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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
    创建对象： 类型 变量名 = new 类型();

    bean相当于创建对象的过程
    id 就相当于 变量名  class 代表是那个类
    property 表示属性  name：类中的属性名
    value 对应于基本类型的值
    ref 对应于引用类型

    其中：MysqlDaoImp的对象是由Spring创建的

    -->
    <bean id="mysqlImp" class="com.chen.Dao.MysqlDaoImp"/>
    <bean id="userdaoImp" class="com.chen.Dao.UserDaoImp"/>
    <bean id="oracleImp" class="com.chen.Dao.OrcalDaoImp">
    	<!--依赖注入 相当于设置参数-->
        <property name="str" value="Spring"/>
    </bean>

    <bean id="userServiceImp" class="com.chen.Service.UserServiceImp">
        <!--依赖注入 相当于设置参数-->
        <property name="userDao" ref="oracleImp"/>
    </bean>
    
</beans>

4.测试

package com.chen.Test;

import com.chen.Service.UserServiceImp;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    public static void main(String[] args) {

        //context相当于容器，从里面可以取东西
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserServiceImp userServiceImp = (UserServiceImp) context.getBean("userServiceImp");
        userServiceImp.getUser();
    }
}

3、依赖注入（DI）

依赖：bean对象的创建，依赖于容器
注入：bean对象的属性，由容器注入

3.1 基于构造器注入

IoC创建对象：默认为无参构造器创建
当IoC使用 有参构造器创建对象时，有三种方式：

package examples;
public class ExampleBean {
    private int years;
	private String ultimateAnswer;

    public ExampleBean(int years, String ultimateAnswer) {
        this.years = years;
        this.ultimateAnswer = ultimateAnswer;
    }
}

1.基于参数类型的方式（不建议使用）

<bean id="exampleBean" class="examples.ExampleBean">
    <constructor-arg type="int" value="7500000"/>
    <constructor-arg type="java.lang.String" value="42"/>
</bean>

2.基于索引的方式

<bean id="exampleBean" class="examples.ExampleBean">
	(索引从0开始)
    <constructor-arg index="0" value="7500000"/>
    <constructor-arg index="1" value="42"/>
</bean>

3.基于属性名的方式

<bean id="exampleBean" class="examples.ExampleBean">
    <constructor-arg name="years" value="7500000"/>
    <constructor-arg name="ultimateAnswer" value="42"/>
</bean>

注意：当加载beans.xml配置文件时，所有的beans.xml下的对象都被创建，存储在Spring容器中,要使用方法getBean()进行取出。

3.2 基于setter注入

通过使用纯setter注入来依赖注入的类。此类是常规的Java。它是一个POJO，不依赖于容器特定的接口，基类或注释。

实例
1.创建实体类bean

package com.chen.pojo;

import java.util.*;

public class Student {

    private String name;
    private Address address;
    private String[] book;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties 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[] getBook() {
        return book;
    }

    public void setBook(String[] book) {
        this.book = book;
    }

    public List<String> getHobbys() {
        return hobbys;
    }

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

    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 getWife() {
        return wife;
    }

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

    public Properties getInfo() {
        return info;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", book=" + Arrays.toString(book) +
                ", hobbys=" + hobbys +
                ", card=" + card +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

package com.chen.pojo;

public class Address {

    private String address;

    public String getAddress() {
        return address;
    }

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

    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
}

2.创建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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--都属于set注入-->
    <bean id="addresses" class="com.chen.pojo.Address">
        <property name="address" value="安徽"/>
    </bean>

    <bean id="student" class="com.chen.pojo.Student">
        <!--普通注入 value-->
        <property name="name" value="陈少"/>
        <!--对象注入 ref-->
        <property name="address" ref="addresses"/>

        <!--数组注入-->
        <property name="book">
            <array>
                <value>唐诗</value>
                <value>宋词</value>
                <value>元曲</value>
                <value>明小说</value>
            </array>
        </property>

        <!--List注入-->
        <property name="hobbys">
           <list>
               <value>吃</value>
               <value>喝</value>
               <value>玩</value>
               <value>乐</value>
           </list>
        </property>

        <!--map注入-->
        <property name="card">
            <map>
                <entry key="idcard" value="123564789"/>
                <entry key="moneycard" value="454655465463212"/>
            </map>
        </property>

        <!--set注入-->
        <property name="games">
            <set>
                <value>lol</value>
                <value>cf</value>
            </set>
        </property>

        <!--null注入-->
        <property name="wife">
            <null/>
        </property>

        <!--properties注入-->
        <property name="info">
            <props>
                <prop key="driver">com.mysql.cj.jdbc</prop>
                <prop key="url">asdadas</prop>
                <prop key="username">root</prop>
                <prop key="password">123456</prop>
            </props>
        </property>
    </bean>    
</beans>

3.测试

package com.chen;

import com.chen.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {

        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");

        System.out.println(student);
        /*
         Student{
            name='陈少',
            Address{address='安徽'},
            book=[唐诗, 宋词, 元曲, 明小说],
            hobbys=[吃, 喝, 玩, 乐],
            card={
                idcard=123564789,
                moneycard=45465546546321
                },
            games=[lol, cf],
            wife='null',
            info={
                password=123456,
                driver=com.mysql.cj.jdbc,
                url=asdadas,
                username=root}
            }

         */
    }
}

3.3 bean的作用域

控制从特定bean定义创建的对象的范围。

singleton：单例模式，即容器中只存在一个全局的对象（默认）

<bean id="accountService" class="com.something.DefaultAccountService"/>

<!-- the following is equivalent, though redundant (singleton scope is the default) -->
<bean id="accountService" class="com.something.DefaultAccountService" scope="singleton"/>

prototype：原型模型，即每次从容器中获取的对象都不同

<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>