Spring

Spring简介

1.解决企业应用开发的复杂性，可以解决Java SE的问题
2.2002年，推出Spring的雏形
3.2004年，Spring正式发布1.0版本（据说Spring的框架是以Interface21的框架进行重新设计，并不断填充内容从而形成）
4.Spring理念：使得现有的技术更易使用。整合现有的技术框架（Spring提供了许多的应用程序架构，包括通讯、数据、事务持久性和网络，还包括基于Spring MVC Web框架等）
5.SSM：Spring SpringMVC Mybatis
-Spring：一个容器会集成很多东西
-Mybatis：半自动化，相对于Hibernate来说可定制性更强，更易于使用。
6.内容准备：

• 官网下载jar包：https://repo.spring.io/release/org/springframework/spring/
  -github下载：https://github.com/spring-projects/spring-framework
• 引入Maven依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.6</version>
</dependency>

Spring的优点：

• Spring是一个开源的免费的框架（容器）
• Spring是一个轻量级的，非入侵式的框架（轻量级：很小巧，下载jar包或者引入依赖就可以使用；非入侵：引入Spring不会对原有的代码产生影响，入侵式则相反）
• 控制反转（IOC），面向切面编程（AOP）
• 支持事务处理
• 能够整合大多数的框架

Spring的组成

扩展

现在化的java开发就是基于Spring的开发

• Spring：
  一个快速开发的脚手架。
  基于SpringBoot可以快速的开发单个微服务
  约定大于配置（按照配置进行搭建）
• Spring Clound
  基于Spring Clound基于Spring Boot实现的
  学习Spring Boot的前提：掌握Spring和SpringMVC

弊端

配置十分繁琐（违背了早期易于使用的理念）

IOC理论推导

1.UserDao接口

package com.test.dao;

public interface UserDao {
    void getUser();
}

2.UserDaoImpl实现类

package com.test.dao;

    public class UserDaoImpl implements UserDao{

    public void getUser() {
        System.out.println("默认获取用户的数据");
    }
}
    package com.test.dao;

    public class UserDaoMysqlImpl implements UserDao{
    public void getUser() {
        System.out.println("Mysql用户获取数据");
    }
}
    package com.test.dao;

    public class UserDaoOracleImpl implements UserDao{
    public void getUser(){
        System.out.println("Oracle用户获取数据");
    }
}

3.UserService接口

package com.test.Service;

public interface UserService {
    void getUser();
}

4.UserService实现类

package com.test.Service;

import com.test.dao.UserDao;
import com.test.dao.UserDaoImpl;
import com.test.dao.UserDaoMysqlImpl;

public class UserServiceImpl implements UserService{
//    重新添加一个UserDaoImpl的实现类实现UserDao的接口，这里的实现参数需要改变，或者UserDao中新添加一个getUsermysql这个方法
//    private UserDao userdao = new UserDaoImpl();
    private UserDao userdao;
/*
* 在以前的业务中，每增加一个Dao层的实现类在后面进行调用的时候都需要修改代码，这使得维护代码的成本极高
* 程序主动创建对象
* */
//  在增加了set方法之后，使用set注入实现，对象的接收，由此程序变成了被动的接受对象，程序不在占据主动性

//  **控制反转的思想：由程序主动创建对象到被动的接收对象（降低耦合性）（依赖注入是实现控制反转的一种方法）
Spring中实现控制反转的是IOC容器，其实现方法是依赖注入**
    public void setUserdao(UserDao userdao){
        this.userdao=userdao;
    }

    public void getUser() {
        userdao.getUser();
    }
//    public void getUsermysql(){
//        usermysqldao.getUser();
//    }
}

IOC创建对象的方式

1.默认使用无参构造
所有的bean一注册就被创建了，并且只有一个对象，（被bean中的class=""引用的类，每次被引用无参构造就被创建）
2.如果使用有参构造有几种创建对象的机会。
（1）下标赋值

<!--有参构造，按照下标注入-->
    <bean id="user2" class="com.test.entity.User">
        <constructor-arg index="0" value="按照下标注入值"/>
    </bean>

(2)按照类型注入

<!--有参构造，按照类型注入（不建议使用）-->
    <bean id="user3" class="com.test.entity.User">
        <constructor-arg type="java.lang.String" value="按照类型注入值"/>
    </bean>

(3)按照参数名注入（一般通过这种方式注入）

<!--有参构造，按照参数名注入-->
    <bean id="user4" class="com.test.entity.User">
        <constructor-arg name="name" value="按照参数名注入"/>
    </bean>
    
    <!--别名配置-->
    <alias name="user4" alias="user4_alias"/>

Spring的配置

1.alias：

<!--有参构造，按照参数名注入-->
    <bean id="user4" class="com.test.entity.User">
        <constructor-arg name="name" value="按照参数名注入"/>
    </bean>
    
    <!--别名配置-->
    <alias name="user4" alias="user4_alias"/>

2.Bean的配置：

<!--
    id：bean的唯一标识符，也就是相当于对象名
    class：对象所对应的全限定名：包名+类型
    name：给id的参数设置别名，功能更加强大可以取多个别名，中间可以使用任意分割符隔开
    -->
    <bean id="userserviceimpl1" class="com.test.Service.UserServiceImpl" name="user7 user0,user99">
        <property name="userdao" ref="usermysqlimpl"></property>
    </bean>

3.import：一般用于团队开发，可以将多个beans.xml合为一个

<!--导入多个bean.xml，将多个人使用的bean.xml合为一个总的，相同名字的bean内容也会合并，标准命名是applicationContext.xml-->
    <import resource="beans.xml"></import>
    <import resource="beans1.xml"></import>
    <import resource="beans2.xml"></import>

依赖注入

1.构造器注入
默认为无参构造注入
有参构造注入分为三种方式（按照下标注入、按照参数类型注入、按照参数名注入）
2.Set方式注入【重点】
-依赖注入：
·依赖：bean对象的创建依赖于容器
·注入：bean对象中的所有属性依赖于，由容器来注入！
测试类：
User.class

package com.test.entity;

	import java.util.*;

	public class User {
    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;//null
    private Properties info;
    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> 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;
    }

    public User(){
        System.out.println("bean一注册就创建了对象");
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name=‘" + name + ‘\‘‘ +
                ", address=" + address +
                ", books=" + Arrays.toString(books) +
                ", hobbys=" + hobbys +
                ", card=" + card +
                ", games=" + games +
                ", wife=‘" + wife + ‘\‘‘ +
                ", info=" + info +
                ‘}‘;
    }
}
`
Address.class
`package com.test.entity;

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 + ‘\‘‘ +
                ‘}‘;
    }
}``
Spring中bean.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="address" class="com.test.entity.Address">
        <property name="address" value="引用类型-中国湖北省"></property>
    </bean>

    <bean id="user" class="com.test.entity.User">
        <!--第一种普通值注入-->
        <property name="name" value="String类型-我叫哈哈哈哈"></property>
        <!--引用注入-->
        <property name="address" ref="address"></property>
        <!--数组注入-->
        <property name="books">
            <array>
                <value>罪与罚</value>
                <value>深入了解JVM</value>
                <value>西游记</value>
            </array>
        </property>
        <!--List集合注入-->
        <property name="hobbys">
            <list>
                <value>打篮球</value>
                <value>打排球</value>
                <value>下棋</value>
            </list>
        </property>
        <!--Map注入-->
        <property name="card">
            <map>
                <entry key="1" value="图书馆卡"></entry>
                <entry key="2" value="食用水卡"></entry>
                <entry key="3" value="寝室门禁卡"></entry>
            </map>
        </property>
        <!--Set集合注入-->
        <property name="games">
            <set>
                <value>英雄联盟</value>
                <value>水果忍者</value>
                <value>王者荣耀</value>
            </set>
        </property>
        <!--Null集合注入，空值跟空串不一样-->
        <property name="wife">
            <null></null>
        </property>
        <property name="info">
            <props>
                <prop key="username">root</prop>
                <prop key="password">root</prop>
                <prop key="url">mysql://1222222:3306</prop>
                <prop key="driver">JDBC:mysql</prop>
            </props>
        </property>
    </bean>
</beans>

3.拓展方式注入
C:命名空间（对应的构造器注入）
需要先引入一些东西（依赖于第三方的约束）：

`xmlns:c="http://www.springframework.org/schema/c"`
		<!--使用P命名空间注入，用于无参构造-->
    `<bean id="userp" class="com.test.entity.User" p:name="p命名空间"></bean>`

P:命名空间（对应的set注入的属性注入）
	需要先引入一些东西（依赖于第三方的约束）：

xmlns:p="http://www.springframework.org/schema/p"`
    `<!--使用P命名空间注入，用于有参构造(有参构造中设置的参数决定了这里得c命名空间能够获取到的参数public User(String name) {
        this.name=name;
    })，通过构造器注入-->
    <bean id="userc" class="com.test.entity.User" c:name="p命名空间"></bean>

Bean的作用域

spring的bean在创建的时候默认是singleton
1.单例模式scope="singleton"

Test.class

2.原型模式scope="prototype"

Test.class

3.request、session、application、只在web开发中使用

Bean的自动装配

• 自动装配是Spring满足bean依赖的一种方式
• Spring会在上下文中自动寻找，并自动给bena装配属性
• 在Spring中的三种装配方式
  1.在xml中显示的配置
  2.在java中显示的配置
  3.使用autowire进行自动装配
  bynname和bytype

<!--<bean id="cat" class="com.test.pojo.Cat" />
    <bean id="dog" class="com.test.pojo.Dog" />
    <bean id="people" class="com.test.pojo.People" >
        <property name="name" value="使用Bean装配"></property>
        <property name="dog" ref="dog"></property>
        <property name="cat" ref="cat"></property>
    </bean>-->`

    <!--使用byname自动装配-->
<!--    <bean id="cat" class="com.test.pojo.Cat" />-->
<!--    <bean id="dog" class="com.test.pojo.Dog" />-->
    <!--byname:会自动在容器的上下文中查找和自己对象set方法后面的值对应的beanid，如果不满足则空指针异常，不能进行自动装配-->
<!--    <bean id="people" class="com.test.pojo.People" autowire="byName">-->
<!--        <property name="name" value="使用Bean装配"></property>-->
<!--    </bean>-->

    <!--使用bytype自动装配-->
<!--    <bean class="com.test.pojo.Cat" />-->
<!--    <bean class="com.test.pojo.Dog" />-->
    <!--bytype:在容器中的上下文，和自己对象属性类型相同的bean，类型相同甚至可以不注册名字也可以使用-->
<!--    <bean id="people" class="com.test.pojo.People" autowire="byType">-->
<!--        <property name="name" value="使用Bean装配"></property>-->
<!--    </bean>-->

使用注解实现自动装配

JDK1.5开始支持注解Spring2.5开始支持注解
要使用注解：
1.导入约束，context约束
2.配置注解的支持
<?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 https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

<context:annotation-config/>

Test.class
package com.test.pojo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

public class People{
private String name;
@Autowired(required = false) //这里的required默认是true就是不允许为空，反之设置为false表示可以为空
@Qualifier(value = "cat123")
//当beans.xml中有多个同类型bean对象时，单独使用@Autowired不能够自动装配成功，可以和@Qualifier搭配着一起使用，指定装配的对象
private Cat cat;
@Autowired
@Qualifier(value = "dog123")
private Dog dog;

public String getName() {
    return name;
}

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

public Cat getCat() {
    return cat;
}

public void setCat(Cat cat) {
    this.cat = cat;
}

public Dog getDog() {
    return dog;
}

public void setDog(Dog dog) {
    this.dog = dog;
}

@Override
public String toString() {
    return "People{" +
            "name=‘" + name + ‘\‘‘ +
            ", cat=" + cat +
            ", dog=" + dog +
            ‘}‘;
}
}
@Resource注解是Java的注解也可以实现自动装配，（对beans.xml中的要求，bean注册的对象要么名字唯一要么类型唯一）
public class People{
private String name;
@Resource(name="cat123")
private Cat cat;
@Autowired
private Dog dog;

}
@Resource与@Autowired的区别：

• 都是用来自动装配的，都可以放在属性字段上
• @Autowired通过byType的方式实现先找byType再找byname，而且必须要求这个对象存在！【常用】（否则会报错）
• @Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下报错！【常用】
• 执行顺序不同：@Autowired通过byType的方式实现先找byType再找byname；@Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现！

扩展

@Nullable 字段标记这个注解，说明这个注解可以为null

使用注解开发

1.bean
2.属性如何注入

package com.test.entity;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

//等价于 <bean id="User" class="com.test.entity.User" />
//@Component 组件  没有显示的名字，名字默认就是类的小写
@Component
@Scope("sighleton") //标注为单例模式
public class User {
    @Value("hhhhh") //相当于<property name="" value=""/> 在类的属性很多的时候还是使用配置文件更加的方便
    private String name ;//= "哈哈哈";

    public String getName() {
        return name;
    }

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

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

3.衍生的注解
@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！

• dao【@Repository】
• service【@Service】
• controller【@Controller】
  这四个注解都是一样的，都是代表将某个类注册到Spring中，装配Bean
  4.自动装配配置
• xml文件配置，或者使用注解实现自动装配
  5.作用域
• @scope("sighleton")：在类中配置注解实现单例模式原型模式的作用域的配置
• 也可以在xml文件中使<bena scope="sighleton"/>进行配置
  6.小结
  xml与注解:
• xml更加的万能，适用于任何场合！维护更加的简单。
• 注解不是自己类使用不了，写在各个类中，维护相对复杂！
  xml与注解最佳实践：
• xml用来管理bean；
• 注解只负责完成属性的注入
• 我们在使用的过程中，需要注意一个问题：xml文件中必须配置开启注解支持，使注解生效。

<!--指定扫描注解的包,这个包下的的注解就会生效-->
    <context:component-scan base-package="com.test.entity"></context:component-scan>
    <!--开启注解支持-->
    <context:annotation-config/>

使用Java的方式配置Spring

不使用Spring的xml配置，全部使用Java（JavaConfig）进行配置
JavaConfig是Spring的一个子项目，在Spring4之后，成为了一个核心功能。
User.class

package com.test.pojo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component //注解的功能：使这个类被Spring接管，注册到容器中
public class User {
    @Value("哈哈")
    private String name;

    public String getName() {
        return name;
    }

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

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

配置类：appConfig.class

package com.test.config;

import com.test.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration  //这个也会被Spring容器托管，注册到容器中，因为他的类上面也有@Component是一个组件
//@Configuration 代表这个类是一个配置类，相当于之前的beans.xml
@ComponentScan("com.test.pojo")  //扫描注解
@Import(appConfig2.class)  //类似于xml中的导入多个bean.xml
public class appConfig {

    //注册一个bean，就相当于之前在xml文件中配置的一个bean标签
    //这个方法的方法名，就相当于bean标签中的id属性
    //这个方法的返回值，就相当于bean标签中的class属性
    @Bean
    public User getUser(){
        return new User();  //就是返回一个要注入到bean的对象。
    }
}

//appConfig2类
package com.test.config;

import com.test.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration  //这个也会被Spring容器托管，注册到容器中，因为他的类上面也有@Component是一个组件
//@Configuration 代表这个类是一个配置类，相当于之前的beans.xml
@ComponentScan("com.test.pojo")  //扫描注解
public class appConfig2 {

    //注册一个bean，就相当于之前在xml文件中配置的一个bean标签
    //这个方法的方法名，就相当于bean标签中的id属性
    //这个方法的返回值，就相当于bean标签中的class属性
    @Bean
    public User user(){
        return new User();  //就是返回一个要注入到bean的对象。
    }
}

MyTest.class

import com.test.config.appConfig;
import com.test.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        //如果完全使用了配置类方式实现去做，我们就只能通过AnnotationConfig上下文来获取容器，通过配置类的class对象加载
        ApplicationContext context = new AnnotationConfigApplicationContext(appConfig.class);
        User user = (User) context.getBean("getUser");
        System.out.println(user.getName());
    }
}

这种纯java配置的方式，在SpringBoot中随处可见。

Spring-IOC

原文：https://www.cnblogs.com/Gpengbolg/p/14724999.html