realLiuSir
首页
归档
标签
分类
友链
关于我
相册
avatar
Articles
62
Tags
17
Categories
10
首页
归档
标签
分类
友链
关于我
相册
Catalog
  1. 1. Spring简介
  2. 2. 导入Spring
  3. 3. IOC
    1. 3.1. 依赖注入
      1. 3.1.1. 构造器注入
      2. 3.1.2. Setter注入
    2. 3.2. 自动装配
      1. 3.2.1. 1、在xml中显式配置：
      2. 3.2.2. 2、注解实现自动装配
      3. 3.2.3. 3、通过JavaConfig实现自动装配
  4. 4. AOP(面向切面编程)
    1. 4.1. AOP核心概念
    2. 4.2. 在Spring中使用AOP
      1. 4.2.1. 方式一：使用Spring的API接口【主要SpringAPI接口实现】
      2. 4.2.2. 方式二：自定义来实现AOP【主要是切面定义】
      3. 4.2.3. 方式三：使用注解实现
  5. 5. 总结
Spring
|Java
Word count:1.9k|Reading time: 6 min
|Post View:

Spring简介

  • Spring是一个开源的免费的框架（容器）！

  • Spring是一个轻量级的、非入侵式的框架！

  • 控制反转（IOC）、面向切面编程（AOP）！

  • 支持事务的处理，对框架整合的支持！

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

导入Spring

Maven仓库：导入webmvc包会自动导入相关依赖；jdbc用于和Mybatis整合。

xml
1
2
3
4
5
6
7
8
9
10
11
12

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-webmvcartifactId>
    <version>5.2.0.RELEASEversion>
dependency>

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-jdbcartifactId>
    <version>5.2.0.RELEASEversion>
dependency>

IOC

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

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

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

依赖注入

依赖注入有两种形式：

  • 构造器注入
  • setter注入。

这是通过反射实现的，这里如果忘记了可以复习一下反射

构造器注入

三种方式：

  • 参数名赋值。
xml
1
2
3
4

<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg name="name" value="臭憨批" />
bean>
  • 下标赋值。
xml
1
2
3
4

<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg index="0" value="憨批" />
bean>
  • 类型赋值。
xml
1
2
3
4

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

Setter注入

Setter注入通过标签设置每一个属性，值得注意的是，在Setter之前其实已经通过无参构造构造了对象，然后Setter为每个属性赋值

xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

<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.kuang.pojo.Address"/>

    <bean id="student" class="com.kuang.pojo.Student">
        
        <property name="name" value="憨批"/>
        
        <property name="address" ref="address"/>
        
        <property name="books">
            <array>
                <value>红楼梦value>
                <value>西游记value>
                <value>水浒传value>
                <value>三国演义value>
            array>
        property>
        
        <property name="hobbies">
            <list>
                <value>听歌value>
                <value>敲代码value>
                <value>看电影value>
            list>
        property>
        
        <property name="card">
            <map>
                <entry key="身份证" value="1555555555"/>
                <entry key="银行卡" value="5555555555"/>
            map>
        property>
        
        <property name="games">
            <set>
                <value>lolvalue>
                <value>wowvalue>
            set>
        property>
        
        <property name="wife">
            <null/>
        property>
        
        <property name="info">
            <props>
                <prop key="driver">com.mysql.jdbc.Driverprop>
                <prop key="url">jdbc:mysql://localhost:3306/newsprop>
                <prop key="root">rootprop>
                <prop key="password">123456prop>
            props>
        property>
    bean>
beans>

人们为了偷懒，还有以下的写法，称为命名空间注入，其中p命名空间是Setter输入，c命名空间是构造器注入：

xml
1
2
3
4

<bean id="user" class="com.kuang.pojo.User" p:name="憨批" p:age="18"/>

<bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="憨批"/>

自动装配

自动装配其实就是将依赖注入“自动化”的一个简化配置的操作

在Spring中有三种装配的方式：

1、在xml中显式配置：

当bean中的属性中包含另外的bean时，我们可以通过byName或者byType的方式自动引入其他的bean，而不用像之前一样通过ref=” “来手动配置

xml
1
2

<bean id="people" class="com.kuang.pojo.People" autowire="byName">bean>
xml
1
2

<bean id="people" class="com.kuang.pojo.People" autowire="byType">bean>

2、注解实现自动装配

使用注解须知：

  1. 导入约束：context约束。
  2. 配置注解的支持：
xml
1
2
3
4
5
6
7
8
9
10
11
12

<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/>

beans>

@Autowired 直接在类的属性或者set方法上使用，当在属性上使用时，就可以不用写set方法了。

如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解@Autowired完成的时候，我们可以使用@Qualifier(value=”xxx”) 去配置@Autowired的使用，指定一个唯一的bean对象注入！

java
1
2
3
4
5
6
7
8
9
public class People {
    @Autowired
    @Qualifier(value="dog11")
    private Dog dog;
    @Autowired
	@Qualifier(value="cat11")
    private Cat cat;
    private String name;
}

与Autowired相同作用的还有@Resource ，二者有些许的区别。

xml与注解最佳实践：

  • xml用来管理bean；

  • 注解只负责完成属性的注入；

  • 我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持。

xml
1
2
3
 
<context:component-scan base-package="com.kuang"/>
<context:annotation-config/>

3、通过JavaConfig实现自动装配

  • 组件扫描
    @Component 表示这个类需要在应用程序中被创建
    @ComponentScan 自动发现应用程序中被创建的类
  • 自动装配
    @Autowired 自动满足Bean之间的依赖
  • 定义配置类
    @Configuration 表示当前类是一个配置类
java
1
2
3
4
5
6
7
8
9
10
11
//@Configuration 表示当前类是一个配置类,就和我们之前看的beans.xml
@Configuration
public class KuangConfig {
    //注册一个bean，就相当于我们之前写的一个bean标签
    //这个方法的名字，就相当于bean标签中的id属性
    //这个方法的返回值，就相当于bean标签中的class属性
    @Bean
    public User user(){
        return new User();//就是返回要注入到bean的对象
    }
}

AOP(面向切面编程)

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

AOP核心概念

  • 横切关注点：跨越应用程序多个模块的方法或功能。即与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。
  • Apsect （即切面）：切面一般定义为一个java类，每个切面侧重于特定的跨领域功能，比如，事务管理或者打印日志
  • advice（通知）：切面必须要完成的工作。它是类中的一个方法
  • target（目标）：被通知对象
  • proxy （代理）：向目标对象应用通知之后创建的对象
  • pointcut（切入点）：切面通知执行的“地点”的定义
  • jointpoint（连接点）：与切入点匹配的执行点

在Spring中使用AOP

使用AOP，需要导入依赖包。

xml
1
2
3
4
5
6

<dependency>
    <groupId>org.aspectjgroupId>
    <artifactId>aspectjweaverartifactId>
    <version>1.9.5version>
dependency>

方式一：使用Spring的API接口【主要SpringAPI接口实现】

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

image-20200106090428369

当我们实现了接口中的方法时，需要在xml中配置AOP，如下所示：

微信截图_20200411235348

方式二：自定义来实现AOP【主要是切面定义】

上一种是使用Spring内置的advice。第二中我们需要自己定义aspect和aspect中的advice。写完之后同样要在xml中配置

微信截图_20200412000307

方式三：使用注解实现

之前的方法需要配置xml，Spring中可以通过注解实现。但是要在xml中开启aop注解支持

xml
1
<aop:aspect-autoproxy>

微信截图_20200412001250

总结

归根到底，Spring解决了一个什么问题呢？

想一想，如果世界上只有一只猫，一只狗，我们有必要创造出一个猫类，然后把这只猫看作猫类的对象吗？我们有必要创造出一个狗类，把这条狗看作狗类的一个对象吗？我们完全可以说，猫类就是猫，猫就是猫类，狗类就是狗，狗就是狗类。但是由于java面向对象的机制，我们却不能这样。

当所有的类只有一个对象时，我们在类与类之间构建的关系其实就是在对象与对象之间构建的关系，但是由于JAVA面向对象的机制，我们不得不先构建出类之间的关系，再new出对象同时构建对象之间的关系。其实对象之间的关系是完全复刻类之间的关系的，我们没必要把这个关系构建两遍，第二遍完全可以交给机器去做，这个机器就是Spring容器。（这里我们只讨论bean的scope="singleton"）

Author: realLiuSir
Link: http://yoursite.com/2020/04/01/Spring/
Copyright Notice: All articles in this blog are licensed under CC BY-NC-SA 4.0 unless stating additionally.
Spring
Donate
  • 微信
    微信
  • 支付寶
    支付寶
繁