2021-09-23 Spring回顾第一天

Spring第一天

一、Spring简介

1. 概念

Spring是一个轻量级的控制反转和面向切面编程的框架

2. 优点

1. 是一个开源、免费的框架
2. 是一个轻量级、非入侵式的框架（只需要导入包）（导了之后对原项目不会有影响）
3. 控制反转、面向切面编程
4. 支持事务的处理，对框架整合的支持

二、Spring组成

1.七大模块

2.三大思想

三、ioc思想

1. 原本：

UserMapper

public interface UserMapper
{
   public void selUser();
}

UserMapperImpl

public class UserMapperImp implements UserMapper
{
    @Override
    public void selUser()
    {
        System.out.println("已找到用户");
    }
}

UserService

public interface UserService
{
     public void selUserService();
}

UserServiceImpl

public class UserServiceImpl implements UserService
{
    @Override
    public void selUserService()
    {
        UserMapper userMapper = new UserMapperImp();
        userMapper.selUser();
    }
}

2. 问题：

此时，若有新的Mapper实现类，在Service实现类中，需要改代码，将

UserMapper userMapper = new UserMapperImp() 

改为新的

UserMapper userMapper = new UserMapperImpl2();

3. 解决办法：

用set方法，在ServiceImpl中不要写死，让用户去传参数

public class UserServiceImpl implements UserService
{
    private UserMapper userMapper;
    public void setUserMapper(UserMapper userMapper)
    {
        this.userMapper=userMapper;
    }
    @Override
    public void selUserService()
    {
        userMapper.selUser();
    }
}

public class TestA
{
    public static void main(String[] args)
    {
       UserService userService=new UserServiceImpl();
       userService.setUserMapper(new UserMapperImpl2());
       userService.selUserService();
    }
}

4. 思想：

原本，程序是在ServiceImpl中主动去创建Mapper对象，控制权在程序员手上 

现在，用了set注入，程序员不再有主动性，而是变成了被动的接收对象
增加类的时候，只需要增加类，其他代码无需改变，由用户去改变选择

从本质上解决了问题，程序员不用去管理对象的创建，系统的耦合性大大降低，更加专注在业务的实现上

这就是ioc的原型，控制反转，控制权由程序员变为用户

四、HelloSpring

1. 导包

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

2. Hello类

public class Hello
{
    private String str;

    public Hello() {
    }

    public String getStr() {
        return str;
    }

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

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

3. beans.xml

  <bean id="hello" class="com.xk.pojo.Hello">
        <property name="str" value="HelloSpring"></property>
    </bean>

4. 实例化容器

 //实例化容器
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

5. 取bean

  //取bean
        Hello hello = context.getBean("hello", Hello.class);

6. 测试

五、ioc创建对象的方式

package com.xk.pojo;

public class User
{
    private int id;
    private String name;

    public User() {
    }

    public User(int id) {
        this.id = id;
    }

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

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



    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

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

1.无参构造器

   <!--通过无参构造创建对象-->
        <bean id="user1" class="com.xk.pojo.User">

        </bean>

//获取spring容器
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//获得bean
User user1 = context.getBean("user1", User.class);
//测试
System.out.println(user1);

2.有参构造器

① 通过下标赋值

 <!--通过下标赋值-->
        <bean id="user" class="com.xk.pojo.User">
               <constructor-arg index="0" value="1"/>
        </bean>

② 通过类型创建

 <!--通过类型创建-->
        <bean id="user" class="com.xk.pojo.User">
                <constructor-arg type="int" value="1"></constructor-arg>
                <constructor-arg type="java.lang.String" value="xk"></constructor-arg>
        </bean>

③ 通过属性名

<!--通过属性名-->
        <bean id="user" class="com.xk.pojo.User">
                <constructor-arg name="id" value="2"></constructor-arg>
                <constructor-arg name="name" value="xk"></constructor-arg>
        </bean>

六、Spring配置

1. 别名

name：原id
alias：别名

 <alias name="hello" alias="hello2"></alias>

2. bean

3. import

一般用于团队开发使用

把配置文件都导到一个中，比如说都导到A.xml中，程序只读取A，就能获得其他里面的bean

<import resource="B.xml"></import>

七、依赖注入DI

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

1. 构造器注入

2. set方式注入

1. 普通值注入
2. Bean注入
3. 数组注入
4. List注入
5. Map注入
6. Set注入
7. null值注入
8. Properties注入

<bean id="user" class="com.xk.pojo.User">
            <property name="id" value="1"></property>
            <property name="name" value="xk"></property>
            <property name="teacher" ref="teacher"></property>
            <property name="books">
                <array>
                    <value>红楼梦</value>
                    <value>三国演义</value>
                </array>
            </property>
            <property name="friends">
                <list>
                    <value>nc</value>
                    <value>ym</value>
                </list>
            </property>
            <property name="sisters">
                <map>
                    <entry key="1" value="大姐"></entry>
                    <entry key="2" value="二姐"></entry>
                </map>
            </property>
            <property name="clothes">
                <set>
                    <value>短袖</value>
                </set>
            </property>
            <property name="pro">
                <props>
                    <prop key="1">111</prop>
                </props>
            </property>
        </bean>

        <bean id="teacher" class="com.xk.pojo.Teacher">
            <property name="id" value="1"></property>
            <property name="name" value="kk"></property>
        </bean>

3. 其他方式注入

八、Bean的作用域

默认为单例，即获取多个bean，但在spring容器中只有一个实例

1. 单例

2. 原型（多例）

每次从容器中getBean时，都会产生一个新的实例

九、Bean的自动装配

自动装配是Spring满足bean依赖的一种方式，Spring会在上下文中自动寻找，并自动给bean装配属性

Spring中的三种装配方式

1. 在xml显示配置（上面的都是）

2. 在java中显示配置

3. 隐式的自动装配bean

使用注解实现自动装配

步骤

1. 导入约束
2. 配置注解的支持

注解

@Autowired

直接在属性上用即可，用了不需要set方法

前提：自动装配的属性在Spring容器中存在，且符合名字Byname，即id和属性名相等

十、使用注解开发

步骤

1. 导入context约束

2. 配置注解的支持

3. 指定要扫描的包，该包下的注解就会生效

分类

1. Bean

@Component 在类上，相当于配了bean

2. 属性

@Value("  ") 在属性上或在set方法上，相当于配了属性值

衍生注解

@Component有几个衍生注解

在web开发中，会用MVC三层架构

1. DAO

@Repository

2. Service

@Service

3. Controller

@Controller

作用域

1. 单例

@Scope("singleton")

2. 多例

@Scope("prototype")

十一、XML与注解

比较

XML，更加万能，适用于任何场景，维护更加简单
注解，不是自己的类用不了，维护比较复杂

实践

XML用来管理bean
注解只用来完成属性的注入