Spring学习笔记第一天

1、Spring

1.1简介

​ Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。

• Spring理念：是现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架
• SSH ：Struct2+Spring+Hibernate
• SSM：SprMVC+Spring+Mybatis

1.2优点

• Spring是一个开源的免费的框架（容器）
• Spring是一个轻量级的、非入侵式的框架
• 控制反转（IOC），面向切面编程（AOP）！
• 支持事务处理，对框架整合的支持！

Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！

1.3组成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-syaa2QoS-1652178519045)(D:\Desktop\学习笔记\图片\image-20220510150011761.png)]

1.4扩展

现代化的java开发，就是基于Spring的开发！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZCa3W7gx-1652178519046)(D:\Desktop\学习笔记\图片\image-20220510150319012.png)]

• Spring Boot
  • 一个快速开发的脚手架
  • 基于SpringBoot可以快速的开发单个微服务。
  • 约定大于配置
• Spring Cloud
  • SpringCloud是基于SpringBoot实现的

现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提需要完全掌握Spring和SpringMVC！

弊端：配置太繁琐，人称“配置地狱”

2、IOC理论推导

例：

​ 用户操作数据库的本质是通过调用service层来调用Dao层，所以用户只需要调用Service层的方法就可以操作数据库

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IdYRdCkH-1652178519047)(D:\Desktop\学习笔记\图片\image-20220510154605949.png)]

UserServiceImpl：

package com.cjp.service;

import com.cjp.dao.UserDao;
import com.cjp.dao.UserDaoImpl;

public class UserServiceImpl implements UserService{
    private UserDao userDao = new UserDaoImpl();

    @Override
    public void getUserService() {
        userDao.getUser();
    }
}

分析：此时UserServiceImpl中的userDao是固定死的，而当UserDao接口的实现类有多个，用户需要使用不同的实现时，就需要修改UserServiceImpl的源码。

优化后的UserServiceImpl：

package com.cjp.service;

import com.cjp.dao.UserDao;

public class UserServiceImpl implements UserService{
    private UserDao userDao;

    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void getUserService() {
        userDao.getUser();
    }
}

分析：修改后UserServiceImpl中的UserDao是没有确定的，而是通过构造器来创建。

前后对比：

• 之前，程序主动创建对象，控制权在程序员手上！
• 使用set注入后，程序不再具有主动性，控制权在用户，程序被动接受对象！

这种思想，从本质上解决了问题，当用户有不同需求时，不需要去修改源码，降低了系统耦合性，可以更加专注在业务的实现上！这是IOC的原型！

IOC本质

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

3、HelloSpring

1.先建一个实体类Hello：

package com.cjp.pojo;

public class Hello {
    private String string;

    public String getString() {
        return string;
    }

    public void setString(String string) {
        this.string = string;
    }

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

2.在resource下新建一个配置文件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">

 <bean id="hello" class="com.cjp.pojo.Hello">
    <property name="string" value="Spring"/>
 </bean>

</beans>

3.测试

import com.cjp.pojo.Hello;
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");
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello);
    }
}

4、IOC创建对象的方式

1、使用无参构造创建对象，默认！

2、假设我们要使用有参构造创建对象。

• 下标赋值

   <bean id="user" class="com.cjp.pojo.User">
      <constructor-arg index="0" value="cjp"/>
   </bean>
  

• 类型赋值

  <bean id="user" class="com.cjp.pojo.User">
      <constructor-arg type="java.lang.String" value="cjp"/>
  </bean>
  

• 直接通过参数名设置

  <bean id="user" class="com.cjp.pojo.User">
      <constructor-arg name="name" value="cjp"/>
  </bean>
  

总结：在配置文件加载的时候，容器中注册的对象就已经初始化了

5、Spring配置

• 别名

<alias name="user" alias="newUser"/>

设置了别名后，也可以使用别名来获取到对象。

• Bean的配置

id：bean的唯一标识符，也就相当于对象名
class：bean对象所对应的全限定名：包名+类名
name：也是别名，而且name可以同时设置多个别名，使用逗号、空格、分号等分隔

• import

当团队开发时，创建了多个beans配置文件，可用import来将多个配置文件导入合并成一个

<?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">

    <import resource="beans.xml"/>
    <import resource="beans1.xml"/>
    <import resource="beans2.xml"/>
    <import resource="beans3.xml"/>

</beans>

6、依赖注入

6.1、构造器注入

​ 使用构造器注入属性

6.2、set方式注入（重点）

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

搭建环境

1.创建复杂实体类：

public class Student {
    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;
    private Properties info;
    //getter setter toString方法省略

package com.cjp.pojo;

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.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">
   <bean id="address" class="com.cjp.pojo.Address">
       <property name="address" value="湖南省长沙市岳麓区"/>
   </bean>

   <bean id="student" class="com.cjp.pojo.Student">
       <!--普通注入-->
       <property name="name" value="cjp"/>
       <!--bean注入-->
       <property name="address" ref="address"/>
       <!--数组注入-->
       <property name="books">
           <array>
               <value>《计算机组成原理》</value>
               <value>《操作系统》</value>
               <value>《编译原理》</value>
               <value>《计算机网络》</value>
           </array>
       </property>
       <!--List注入-->
       <property name="hobbys">
           <list>
               <value>唱</value>
               <value>跳</value>
               <value>rap</value>
               <value>篮球</value>
           </list>
       </property>
       <!--Map注入-->
       <property name="card">
           <map>
               <entry key="饭卡" value="12143432"/>
               <entry key="校园卡" value="2435657"/>
               <entry key="银行卡" value="3943759536784"/>
           </map>
       </property>
       <!--Set注入-->
       <property name="games">
           <set>
               <value>原神</value>
               <value>王者荣耀</value>
               <value>火影忍者</value>
           </set>
       </property>
       <!--null注入-->
       <property name="wife">
           <null/>
       </property>
       <!--properties注入-->
       <property name="info">
           <props>
               <prop key="学号">20192712</prop>
               <prop key="班级">风景园林2班</prop>
               <prop key="身高">183cm</prop>
           </props>
       </property>


   </bean>

</beans>

3.测试

import com.cjp.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='cjp',
              address=Address{address='湖南省长沙市岳麓区'},
               books=[《计算机组成原理》, 《操作系统》, 《编译原理》, 《计算机网络》],
                hobbys=[唱, 跳, rap, 篮球],
                card={饭卡=12143432, 校园卡=2435657, 银行卡=3943759536784},
                games=[原神, 王者荣耀, 火影忍者],
                wife='null',
                info={学号=20192712, 班级=风景园林2班, 身高=183cm}}
     */
}

6.3、拓展方式注入

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

    <bean id="user" class="com.cjp.pojo.User" p:age="18" p:name="cjp"/>
    <bean id="user2" class="com.cjp.pojo.User" c:name="aas" c:age="10"/>

</beans>

注意：

1.p命名空间和c命名空间不能直接使用，需要导入xml约束

2.p命名需要无参构造

3.c命名需要有构造