Spring学习笔记

最新推荐文章于 2023-02-10 03:17:59 发布

程序员Realeo

最新推荐文章于 2023-02-10 03:17:59 发布

阅读量122

点赞数

分类专栏： Java后端文章标签： Spring IOC AOP SSM JAVA

本文链接：https://blog.csdn.net/perfect_zdq/article/details/120472149

版权

Java后端专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文深入介绍了Spring框架的核心特性，包括依赖注入（DI）和面向切面编程（AOP）。详细阐述了IOC的概念，通过实例展示了如何通过setter注入和XML配置创建对象。此外，还讲解了Bean的作用域、自动装配以及注解在Spring中的应用。最后，探讨了Spring AOP在事务管理中的重要性，并简要提及了与Mybatis的整合。

摘要由CSDN通过智能技术生成

Spring

依赖

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>5.0.5.RELEASE</version>
</dependency>
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-jdbc</artifactId>
   <version>5.0.5.RELEASE</version>
</dependency>

优点

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

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

组成

IOC理论推导

UserDao接口
UserDaoImpl实现类
UserService业务接口
UserServiceImpl业务实现

问题：用户需求会影响原有代码，需要根据需求修改原有代码。如果程序代码量庞大，修改代价昂贵。

private UserDao userDao;
//利用set进行动态实现值的注入
public void setUserDao(UserDao userDao){
    this.userDao = userDao;
}

之前程序主动创建对象，控制权在程序员手上。
使用了set注入后，程序不再具有主动性，而是变成了被动的接受对象。

这种思想从本质上解决了问题，程序员不用管理对象的创建。系统的耦合性大大降低，可以更加专注业务层实现。这是IOC的原型。

IOC本质

控制反转ioc(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法。所谓控制反转就是获取依赖对象的方式反转了。
采用xml方式配置Bean的时候，Bean的定义信息和实现分离，采用注解把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到零配置的目的。
控制反转是一种描述(xml或注解)并通过第三方去生产获取特定对象的方式，在Spring中实现控制反转的是IoC容器，其实现方式是依赖注入(Dependency Injection,DI)。

Hello Spring(set方式注入)

实体类

public class Hello {
   private String str;
   
   public String getStr() {
       return str;
   }
   //依赖set方法进行注入
   public void setStr(String str) {
       this.str = str;
   }
   @Override
   public String toString() {
       return "Hello{" +
               "str='" + str + '\'' +
               '}';
   }
}

Spring容器，Bean配置

<?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">
    <!--使用Spring创建对象，在Spring这些都称为Bean
    类型 变量名 = new 类型();
    Hello hello = new hello();
    id = 变量名
    class = new 的对象
    property 相当于给对象中的属性设置一个值
    -->
    <bean id="hello" class="com.zdq.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>
</beans>

测试

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"beans.xml"});
        //对象现在都在Spring中管理，使用直接去里面取出来就可以
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.getStr());
    }
}

控制反转
- 控制：谁来控制对象的创建，传统的应用程序的对象是由程序本身控制创建的，使用Spring后对象是由spring来创建的。
- 反转：程序本身不创建对象，而变成被动的接受对象。
- 依赖注入：就是利用set方法来进行注入的。
- IOC：是一种编程思想，由主动编程编程被动的接受。对象由Sping来创建，管理，装配，实现不同操作，只需要改动xml配置文件，不需要改动源代码。

IOC创建对象的方式

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

<!--使用无参构造创建对象，默认！-->
<property name="name" value="无参构造创建对象"/>

使用有参构造创建对象

下标赋值

//创建有参构造干掉无参构造，
public User(String s){
    this.name = s;
}

<!--1。下标赋值-->
<constructor-arg index="0" value="有参构造创建对象"/>

通过唯一类型赋值，存在多个相同类型不支持，不推荐使用

<constructor-arg type="java.lang.String" value="通过唯一类型赋值"/>

直接通过参数名赋值

<constructor-arg name="s" value="直接通过参数名赋值"/>

总结：在配置文件xml加载的时候容器管理的对象就已经初始化了！

Spring配置

别名

<!--创建的对象变量名为user或为user2，两个都可以访问-->
<alias name="user" alias="user2"/>

Bean的配置

<!--
id:bean的唯一标识符，相当于对象名
class:bean对象对应的全限定名，包名+类名
name:同alias且更高级，可同时取多个别名,常用分隔符都可以
scope:作用域，默认为单例模式
-->
<bean id="user" class="com.zdq.pojo.User" name="user3 user4,user5;user6" scope="singleton">

import

import一般用于团队开发使用，可以将多个配置文件导入合并为一个:applicationContext.xml。

<import resource="beans.xml"/>

依赖注入

构造器注入

set方法注入(重点)

依赖注入：Set注入！
- 依赖:bean对象的创建依赖容器
- 注入:bean对象中的所有属性，由容器来注入
各种类型注(复杂类型)

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 + '\'' +
                '}';
    }
}

测试对象

@Data
public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbies;
    private Map<String,String> card;
    private Set<String> game;
    private String wife;
    private Properties info;
    
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address.toString() +
                ", books=" + Arrays.toString(books) +
                ", hobbies=" + hobbies +
                ", card=" + card +
                ", game=" + game +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

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="address" class="com.zdq.pojo.Address">
      <property name="address" value="重庆"/>
  </bean>
  
  <bean id="student" class="com.zdq.pojo.Student">
      <!--第一种，常见类型值注入，value-->
      <property name="name" value="zdq"/>
      <!--第二种，bean注入，ref-->
      <property name="address" ref="address"/>
      <!--第三种，数组注入，ref-->
      <property name="books">
          <array>
              <value>红楼梦</value>
              <value>水浒传</value>
              <value>西游记</value>
              <value>三国演义</value>
          </array>
      </property>
      <!--第四种，List-->
      <property name="hobbies">
          <list>
              <value>打篮球</value>
              <value>听音乐</value>
              <value>敲代码</value>
              <value>看电影</value>
          </list>
      </property>
      <!--第五种，Map-->
      <property name="card">
          <map>
              <entry key="身份证" value="123456"/>
              <entry key="学生卡" value="1314"/>
          </map>
      </property>
      <!--第六种，Set-->
      <property name="game">
          <set>
              <value>LOL</value>
              <value>COC</value>
              <value>BOB</value>
          </set>
      </property>
      <!--第七种，null-->
      <property name="wife">
          <null/>
      </property>
      <!--第八种，properties-->
      <property name="info">
          <props>
              <prop key="driver">oracle.driver</prop>
              <prop key="url">www.baidu.com</prop>
              <prop key="username">root</prop>
              <prop key="password">20210801</prop>
          </props>
      </property>
  </bean>
</beans>

测试类

public class MyTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.toString());
    }
}

拓展注入方式

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">
            <!--注意:要添加C命名空间注入及P命名空间注入依赖约束-->
        <!--P(property)命名空间注入，可以直接注入属性的值-->
        <bean id="user1" class="com.zdq.pojo.User" p:name="zdq1" p:age="24"/>
        <!--c(construct-args)命名空间注入，依赖有参构造注入-->
        <bean id="user2" class="com.zdq.pojo.User" c:name="zdq2" c:age="24"/>
    </beans>

Bean的作用域Scope

单例模式(默认),每次get同一id时都为同一对象

    <bean id="user2" class="com.zdq.pojo.User" c:name="zdq2" c:age="24" scope="singleton"/>

原型模式：每次从容器中get的时候，都会产生一个新对象

<bean id="user2" class="com.zdq.pojo.User" c:name="zdq2" c:age="24" scope="prototype"/>

其余的request、session、application这些在web开发中用到

Bean的自动装配

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

在Spring中的装配的方式

在xml中显式的配置

<bean id="cat" class="com.zdq.pojo.Cat"/>
<bean id="dog" class="com.zdq.pojo.Dog"/>
<bean id="people" class="com.zdq.pojo.People">
    <property name="name" value="zdq"/>
    <property name="cat" ref="cat"/>
    <property name="dog" ref="dog"/>
</bean>

在java中显式配置(JavaConfig)
隐式的自动装配Bean(byName byType自动装配【重要】)

<bean id="cat" class="com.zdq.pojo.Cat"/>
<bean id="dog" class="com.zdq.pojo.Dog"/>
<!--
byName:会自动在容器上下文中查找和自己对象set方法后面值对应的beanid。所以id得严格对应。
byType:会自动在容器上下文中查找和自己对象set方法属性对应的class。所以属性得全局唯一。
-->
<bean id="people" class="com.zdq.pojo.People" autowire="byType">
    <property name="name" value="zdq"/>
</bean>

使用注解实现自动装配

1。jdk1.5支持注解，Spring2.5支持注解
使用注解须知：
1。导入context约束
2。配置注解的支持：context:annotation-config/(重要)

<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
              http://www.springframework.org/schema/beans/spring-beans.xsd
              http://www.springframework.org/schema/context
              http://www.springframework.org/schema/context/spring-context.xsd">
    <context:annotation-config/>
</beans>

@Autowired
直接在属性上使用即可，也可以在set方法上使用。
使用Autowired可以不用编写Set方法，前提是这个自动装配的属性在IOC(Spring)容器中存在，且符合名字byname！

* @Autowired(required = false)：自动装配通过类型、名字。可用于属性和Set方法，用于属性时可以不要Set方法。显示设置required属性为false，说明这个对象允许为null否则不允许为空
* @Nullable：字段标记了这个注解说明这个字段可以为null
* @Qualifier(value="xxx")：如果存在相同属性，@Autowired不能唯一自动装配上属性，通过此注解可指定bean中id为xxx装配属性
* @Resource：自动装配通过名字、类型

使用注解开发

在Spring4后，要使用注解开发，必须要保证AOP的包导入了，使用需要导入context约束，增加注解的支持！

bean

<?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
                http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context.xsd">
    <!--指定扫描的包，这个包下所有的注解都会生效-->
    <context:component-scan base-package="com.zdq"/>
    <context:annotation-config/>
</beans>

属性如何注入

@Component//等价于xml中配置<bean id="user" class="com.zdq.pojo.User"/>
public class User {
    @Value("小明")//等价于xml中配置<property name="name" value="小明"/>
    private String name;
}

衍生的注解

@Component衍生的注解,在Web开发中，会按照mvc三层架构分层！都代表组件(衍生)功能等效，都是代表将某个类注册到Spring中，装配Bean。
- @Service：service层
- @Controller：controller层
- @Repository：dao层

自动装配

@Autowired：自动装配通过类型、名字。如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value=“xxx”)
@Nullable：字段标记了这个注解说明这个字段可以为null
@Resource：自动装配通过名字、类型

@Resource和Autowired的区别：

都是用来自动装配的，都可以放在属性字段和Set方法上
@Autowired 通过byType的方式实现，而且必须要求这个对象存在！(常用)
@Resource 默认通过byName的方式实现，如果找不到名字，则通过byType实现！两个都找不到的情况下报错(常用)
两者执行顺序不同：@Autowired通过byType方式实现，@Resource默认通过byName实现

作用域

@Scope(“singleton” )

小结

xml与注解
- xml更加万能，适用于任何场合，维护简单方便。
- 注解只能自己的类自己使用，分散维护相对复杂！
xml与注解的最佳实践
- xml用来管理bean(实例出对象)
- 注解负责完成属性值的注入
- 使用注解一定要在xml中开启注解支持和扫描对应的包

<!--指定扫描的包，这个包下所有的注解都会生效-->
<context:component-scan base-package="com.zdq"/>
<context:annotation-config/>

JavaConfig SpringBoot随处可见

使用Java的方式配置Spring，完全替代xml配置
JavaConfig是Spring的一个子项目，在Spring4后成为了一个核心功能。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P4KkiNuB-1632561776189)(media/16324147828091/16324155551665.jpg)]

实体类

public class User {
    private String name;
    
    public String getName() {
        return name;
    }
    @Value("小明")
    public void setName(String name) {
        this.name = name;
    }
}

配置类

@Configuration//作用于自定义类，使其成为配置类，等效于xml配置的Beans
@ComponentScan("com.zdq.pojo")//相当于xml中使用 <context:component-scan base-package="com.zdq"/>
@Import(myConfig2.class)
public class myConfig {
    /*
    * 作用于配置类中的方法,相当于xml中一个bean标签，方法名相当于id，方法返回属性相当于class属性
    * */
    @Bean
    public User getUser(){
        return new User();//返回要注入到bean的对象
    }
}

测试类

public class MyTest {
    public static void main(String[] args) {
        //通过配置类方式取代xml配置，只能通过AnnotationConfig上下文来获取容器，通过配置类的class对象加载
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(myConfig.class);
        User getUser = context.getBean("getUser", User.class);
        System.out.println(getUser.getName());
    }
}

代理模式

SpringAOP的底层

代理模式的分类
- 静态代理
- 动态代理
角色分析
- 抽象角色：一般使用接口或者抽象类解决
- 真是角色：被代理的角色
- 代理角色：代理角色，一般会有附属操作
- 客户：直接访问代理完成事务

静态代理

接口

public interface Rent {
 void rent();
}

真实角色

public class Host implements Rent{
    
public void rent() {
        System.out.println("房东要出租房子");
    }
}

代理角色

public class Proxy {
    private Host host;//组合优于继承
    
    public Proxy() {
    }
    
    public Proxy(Host host) {
        this.host = host;
    }
    
    public void rent(){
        seeHouse();
        host.rent();
        hetong();
        fare();
    }
    
    public void seeHouse(){
        System.out.println("看房子");
    }
    
    public void hetong(){
        System.out.println("合同");
    }
    
    public void fare(){
        System.out.println("收费");
    }
}

客户端访问代理角色

public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理，中介帮房东租房子，但也会有一些附属操作
        Proxy proxy = new Proxy(host);
        //直接找中介完成租房子
        proxy.rent();
    }
}

代理模式的好处
- 可以使真实角色的操作更加存粹，不用关注一些公共业务
- 公共业务交给代理角色，实现业务的分工
- 公共业务发生扩展时，方便集中管理
缺点
- 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低

动态代理

动态代理和静态代理角色一样
动态代理的类是动态生成的
动态代理分为两大类：基于接口的动态代理、基于类的动态代理
- 基于接口的动态代理：jdk动态代理
- 基于类的动态代理：cglib
- java字节码实现：javasist

需要了解两个类：Proxy：代理、InvocationHandler：调用处理程序

Proxy：生成动态代理实例
InvocationHandler：调用处理程序并返回结果
动态代理的好处
- 可以使真实角色的操作更加存粹，不用关注一些公共业务
- 公共业务交给代理角色，实现业务的分工
- 公共业务发生扩展时，方便集中管理
- 一个动态代理类代理的是一个接口，一般就是对应的一类业务
- 一个动态代理类可以代理多个类，只要实现了同一个接口即可

AOP

什么是AOP

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP在Spring中的作用

提供声明式事务:允许用户自定义切面

横切关注点:跨越应用程序多个模块的方法或功能.既是,与我们业务逻辑无关,但是我们需要关注的部分,就是横切关注点.如日志,安全,缓存,事务等…
切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
目标（Target）：被通知对象。
代理（Proxy）：向目标对象应用通知之后创建的对象。
切入点（PointCut）：切面通知执行的 “地点”的定义。
连接点（JointPoint）：与切入点匹配的执行点。

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

即 AOP 在不改变原有代码的情况下 , 去增加新的功能 .

使用Spring实现AOP

导入依赖包

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>

方式一：使用Spring的API接口
- 接口
- 实现类
- 前置通知
- 后置通知
- Bean配置
- 测试
方式二：自定义实现【主要是切面定义】
方式三：使用注解实现

整合Mybatis

步骤：
- 1.导入相关jar包
  - junit
  - mybatis
  - mysql数据库
  - spring相关
  - aop植入
  - mybatis-spring
- 编写测试文件
- 测试

Mybatis

编写实体类
编写核心配置文件
编写接口
编写Mapper.xml
测试

Mybatis-Spring

编写数据源配置dataSource
sqlSessionFactory
SqlSessionTemplate
给接口加实现类
实现类注入到Spring中
测试

声明式事务

事务
- 把一组业务当成一个业务来做，要么都成功，要么都失败
- 事务在项目开发中十分重要，涉及到数据一致性问题，不能马虎！
- 确保完整性和一致性
事务的ACID原则
- 原子性：要么都成功，要么都失败
- 一致性：要么都成功，要么都失败
- 隔离性：多个业务操作同一个资源，互相隔离不影响数据正确性，防止数据损坏
- 持久性：事务一旦提交，结果都不会被影响持久化写到存储器中
Spring中的事务管理
- 声明式事务：AOP方式横切进去
- 编程式事务：在代码中进行管理，例如try-catch回滚
为什么需要事务
- 如果不配置事务，可能存在数据提交不一致的情况
- 若果不在Spring中配置声明式事务，需要在代码中手动配置事务
- 事务在项目开发中十分重要，涉及到数据一致性和完整性，不容马虎！