JAVA学习之路（四）——Spring

已于 2024-12-06 20:33:56 修改
阅读量1.2k 收藏 8
点赞数 36
文章标签： java 学习 spring
于 2024-12-06 19:55:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_46747954/article/details/144271844
版权

JAVA学习之路（四）——Spring

说明

本文仅供本人学习，如果有不对的地方欢迎大家一起讨论

记录JAVA的学习路程——Spring

什么是Spring

简介

  • Spring 是一个开源框架，它由 Rod Johnson 创建。

  • Spring 框架是以 interface21 框架为基础，经过重新设计并不断丰富其内涵，于2004年3月24日发布了1.0版本。

  • Spring理念：使用现有技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！

    • SSH：Struct2 + Spring + Hibernate
    • SSM：SpringMVC + Spring + MyBatis

优点

  1. Spring 是一个免费的开源的框架！
  2. Spring 是一个轻量级的、非入侵式的框架！
  3. 控制反转（IoC），面向切片（AOP）！
  4. 支持事务的处理，对框架整合的支持！
Spring 是一个轻量级的控制反转 ( IoC ) 和面向切面 ( AOP ) 的容器框架。

组成

<Spring的组成>

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

IoC

  1. Dao 接口

    public interface UserDao {
    public void getUser();
}

  2. DaoImpl 实现类

    public class UserDaoImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("获取用户信息");
    }
}

  3. Service 业务接口

    public interface UserService {
    void getUser();
}

  4. ServiceImpl 业务实现类

    public class UserServiceIml implements UserService{

    private UserDao userDao = new UserDaoImpl();

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

如果需要增加业务：

public class UserDaoMySQLImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("获取MySQL用户信息");
    }
}

public class UserDaoOracleImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("获取Oracle用户信息");
    }
}

则需要更改ServiceImpl 中的代码：

public class UserServiceIml implements UserService{
    private UserDao userDao = new UserDaoMySQLImpl();
	//private UserDao userDao = new UserDaoOracleImpl();
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

用户的需求可能会影响原来的代码，需要根据用户的需求去修改原代码！如果代码量十分大，修改一次的成本就会十分昂贵！

于是设计了一个Set接口实现：

public class UserServiceIml implements UserService{

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void getUser() {
        userDao.getUser();
    }
}
  • 之前，是程序主动创建对象，控制权在程序员手上！
  • 使用set注入之后，程序不在具有主动性，而是变成了被动的接受对象！

这种思想，从本质上解决了问题，程序员不需要再去管理对象的创建了。系统的耦合性大大降低，程序员可以专注于业务代码的编写。这是IOC的原型。

IoC的本质

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

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。

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

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

案例

创建Maven项目，并在pom文件导入spring的依赖：

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

创建一个Hello 的对象

public class Hello {
    private String name;

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

    public void show(){
        System.out.println("Hello,"+ name );
    }

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

再创建一个.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就是java对象 , 由Spring创建和管理的对象
    id: 唯一标识符
    class: 要创建的对象类型
    property: 对象的属性值
    -->
    <bean id="hello" class="com.spring.pojo.Hello">
        <property name="name" value="Spring"/>
    </bean>

</beans>

测试类：

@Test
public void test(){
    //解析beans.xml文件 , 生成管理相应的Bean对象
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    //getBean : 参数即为spring配置文件中bean的id .
    Hello hello = (Hello) context.getBean("hello");
    System.out.println(hello.toString());
    hello.show();
}
  • Hello 对象是谁创建的 ? hello 对象是由Spring创建的
  • Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的

这个过程就叫控制反转 :

  • 控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
  • 反转 : 程序本身不创建对象 , 而变成被动的接收对象 .

依赖注入 : 就是利用set方法来进行注入的

IoC是一种编程思想，由主动的编程变成被动的接收

IoC创建对象方式

通过无参构造方法创建

User.java

public class User {

    private String name;

    public User() {
        System.out.println("user无参构造方法");
    }

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

    public void show() {
        System.out.println("name=" + name);
    }

}

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="user" class="com.spring.pojo.User">
        <property name="name" value="John"/>
    </bean>
</beans>

测试

@Test
public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    //在执行getBean的时候, user已经创建好了 , 通过无参构造
    User user = (User) context.getBean("user");
    //调用对象的方法 .
    user.show();
}

结果：

user无参构造方法
name=John

通过有参构造方法创建

User.java

public class User {

    private String name;

    public User(String name) {
        this.name = name;
        System.out.println("user有参构造方法");
    }

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

    public void show() {
        System.out.println("name=" + name);
    }

}

beans.xml 有三种方式编写：

<!-- 第一种根据index参数下标设置 -->
<bean id="user" class="com.spring.pojo.User">
    <!-- index指构造方法 , 下标从0开始 -->
    <constructor-arg index="0" value="Tom"/>
</bean>

<!-- 第二种根据参数名字设置 -->
<bean id="userT" class="com.spring.pojo.User">
   <!-- name指参数名 -->
   <constructor-arg name="name" value="Tom"/>
</bean>

<!-- 第三种根据参数类型设置 -->
<bean id="userT" class="com.spring.pojo.User">
   <constructor-arg type="java.lang.String" value="Tom"/>
</bean>

测试：

@Test
public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    //在执行getBean的时候, user已经创建好了 , 通过无参构造
    User user = (User) context.getBean("user");
    //调用对象的方法 .
    user.show();
}

结果：

user有参构造方法
name=Tom

Spring配置

别名

alias 设置别名 , 为bean设置别名 , 可以设置多个别名

<!--设置别名：在获取Bean的时候可以使用别名获取-->
<alias name="userT" alias="userNew"/>

Bean的配置

<!--bean就是java对象,由Spring创建和管理-->

<!--
   id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
   如果配置id,又配置了name,那么name是别名
   name可以设置多个别名,可以用逗号,分号,空格隔开
   如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;

class是bean的全限定名=包名+类名
-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

import

一般用于团队开发，可以将多个配置文件合并为一个。

<import resource="{path}/beans.xml"/>

依赖注入

概念

  • 依赖注入（Dependency Injection,DI）。
  • 依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 .
  • 注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 .

构造器注入

见上：IoC创建对象方式

Set方式注入

要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is .

测试：

pojo包下创建两个类

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
 
 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;
 
     public void setName(String name) {
         this.name = name;
    }
 
     public void setAddress(Address address) {
         this.address = address;
    }
 
     public void setBooks(String[] books) {
         this.books = books;
    }
 
     public void setHobbys(List<String> hobbys) {
         this.hobbys = hobbys;
    }
 
     public void setCard(Map<String, String> card) {
         this.card = card;
    }
 
     public void setGames(Set<String> games) {
         this.games = games;
    }
 
     public void setWife(String wife) {
         this.wife = wife;
    }
 
     public void setInfo(Properties info) {
         this.info = info;
    }
 
     public void show(){
         System.out.println("name="+ name
                 + ",address="+ address.getAddress()
                 + ",books="
        );
         for (String book:books){
             System.out.print("<<"+book+">>\t");
        }
         System.out.println("\n爱好:"+hobbys);
 
         System.out.println("card:"+card);
 
         System.out.println("games:"+games);
 
         System.out.println("wife:"+wife);
 
         System.out.println("info:"+info);
 
    }
 }

1、常量注入

 <bean id="student" class="com.kuang.pojo.Student">
     <property name="name" value="小明"/>
 </bean>

2、Bean注入

注意点：这里的值是一个引用，ref

 <bean id="addr" class="com.spring.pojo.Address">
     <property name="address" value="重庆"/>
 </bean>
 
 <bean id="student" class="com.spring.pojo.Student">
     <property name="name" value="小明"/>
     <property name="address" ref="addr"/>
 </bean>

3、数组注入

 <bean id="student" class="com.spring.pojo.Student">
     <property name="name" value="小明"/>
     <property name="address" ref="addr"/>
     <property name="books">
         <array>
             <value>西游记</value>
             <value>红楼梦</value>
             <value>水浒传</value>
         </array>
     </property>
 </bean>

4、List注入

 <property name="hobbys">
     <list>
         <value>听歌</value>
         <value>看电影</value>
         <value>爬山</value>
     </list>
 </property>

5、Map注入

 <property name="card">
     <map>
         <entry key="中国邮政" value="123456"/>
         <entry key="建设" value="654321"/>
     </map>
 </property>

6、set注入

 <property name="games">
     <set>
         <value>LOL</value>
         <value>BOB</value>
         <value>COC</value>
     </set>
 </property>

7、Null注入

 <property name="wife"><null/></property>

8、Properties注入

 <property name="info">
     <props>
         <prop key="学号">20190604</prop>
         <prop key="性别">男</prop>
         <prop key="姓名">小明</prop>
     </props>
 </property>

测试类：

@Test
public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    Student student = (Student) context.getBean("student");
    student.show();
}

结果：

name=小明,address=重庆,books=
<<西游记>>	<<红楼梦>>	<<水浒传>>	
爱好:[听歌, 看电影, 爬山]
card:{中国邮政=123456, 建设=654321}
games:[LOL, BOB, COC]
wife:null
info:{姓名=小明, 学号=20190604, 性别=男}

拓展方式注入

p命名和c命名注入

  • P命名空间注入 : 需要在头文件中加入约束文件
导入约束 : xmlns:p="http://www.springframework.org/schema/p"
  • c 命名空间注入 : 需要在头文件中加入约束文件
 导入约束 : xmlns:c="http://www.springframework.org/schema/c"

注意：c命名需要使用有参构造器注入，实质上c就是构造器注入

Bean的作用域

在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为bean。简单地讲，bean就是由IoC容器初始化、装配及管理的对象，bean 作用域用于确定哪种类型的bean实例应该从Spring容器中返回给调用者。

目前Spring Bean 的作用域或者说范围主要有五种。

作用域描述
singleton在spring IoC容器仅存在一个Bean实例，Bean以单例方式存在，bean作用域范围的默认值。
prototype每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时，相当于执行newXxxBean()。
request每次HTTP请求都会创建一个新的Bean，该作用域仅适用于web的Spring WebApplicationContext环境。
session同一个HTTP Session共享一个Bean，不同Session使用不同的Bean。该作用域仅适用于web的Spring WebApplicationContext环境。
application限定一个Bean的作用域为ServletContext的生命周期。该作用域仅适用于web的Spring WebApplicationContext环境。

request、session作用域仅在基于web的应用中使用，只能用在基于web的Spring ApplicationContext环境。

Singleton

当一个bean的作用域为Singleton，那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。

Singleton是单例类型，是spring的默认模式，就是在创建起容器时就同时自动创建了一个bean的对象，不管你是否使用，他都存在了，每次获取到的对象都是同一个对象。注意，Singleton作用域是Spring中的缺省作用域。要在XML中将bean定义成singleton，配置如下：

<bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">

Prototype

当一个bean的作用域为Prototype，表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。

Prototype是原型类型，它在我们创建容器的时候并没有实例化，而是当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。根据经验，对有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。在XML中将bean定义成prototype，可以这样配置：

 <bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>  
  或者
 <bean id="account" class="com.foo.DefaultAccount" singleton="false"/>

Request、Session、application

这几个只在web端使用。

自动装配

  • 自动装配是使用spring满足bean依赖的一种方法
  • spring会在应用上下文中为某个bean寻找其依赖的bean。

Spring中bean有三种装配机制，分别是：

  1. 在xml中显式配置；
  2. 在java中显式配置；
  3. 隐式的bean发现机制和自动装配。

Spring的自动装配需要从两个角度来实现，或者说是两个操作：

  1. 组件扫描(component scanning)：spring会自动发现应用上下文中所创建的bean；
  2. 自动装配(autowiring)：spring自动满足bean之间的依赖，也就是我们说的IoC/DI；

组件扫描和自动装配组合发挥巨大威力，使得显示的配置降低到最少。

**推荐不使用自动装配xml配置 , 而使用注解 **

byName

autowire byName (按名称自动装配)

由于在手动配置xml过程中，常常发生字母缺漏和大小写等错误，而无法对其进行检查，使得开发效率降低。

采用自动装配将避免这些错误，并且使配置简单化。

修改bean配置，增加一个属性 autowire=“byName”

小结：

当一个bean节点带有 autowire byName的属性时。

  1. 将查找其类中所有的set方法名，例如setCat，获得将set去掉并且首字母小写的字符串，即cat。
  2. 去spring容器中寻找是否有此字符串名称id的对象。
  3. 如果有，就取出注入；如果没有，就报空指针异常。

byType

autowire byType (按类型自动装配)

使用autowire byType首先需要保证：同一类型的对象，在spring容器中唯一。如果不唯一，会报不唯一的异常。

NoUniqueBeanDefinitionException

小结：

  • byname的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致

  • bytype的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致

使用注解

需要导入 context 约束

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

</beans>

开启属性注解支持

<context:annotation-config/>

@Autowired

  • @Autowired是按类型自动转配的，不支持id匹配。
  • 需要导入 spring-aop的包！
  • 直接在属性上使用即可，也可以在set 方式上使用。
  • 使用Autowired 后，可以不用编写se的方法了，前提是自动装配的属性在 IoC 容器中存在（byname）

@Autowired(required=false) 说明：false，对象可以为null；true，对象必须存对象，不能为null。

@Qualifier

如果@Autowired 自动装配的环境比较复杂，自动装备无法通过@Autowired完成时，可以使用@Qualifier（value=”xxx“）配合使用

  • @Autowired是根据类型自动装配的，加上@Qualifier则可以根据byName的方式自动装配
  • @Qualifier不能单独使用。

@Resource

  • @Resource如有指定的name属性，先按该属性进行byName方式查找装配；
  • 其次再进行默认的byName方式进行装配；
  • 如果以上都不成功，则按byType的方式自动装配。
  • 都不成功，则报异常。

小结

@Autowired与@Resource异同：

1、@Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。

2、@Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用

3、@Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先byName。

使用注解开发

想要使用注解形式，必须得要引入aop的包！在配置文件当中，还得要引入一个context约束：

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

</beans>

Bean的实现

  1. 配置扫描哪些包下的注解

    <!--指定注解扫描包-->
<context:component-scan base-package="com.spring.pojo"/>

  2. 在指定包下编写类，增加注解

    @Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
   public String name = "小明";
}

属性注入

  1. 可以不用提供set方法，直接在直接名上添加@value(“值”)

    @Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
   @Value("小明")
   // 相当于配置文件中 <property name="name" value="小明"/>
   public String name;
}

  2. 如果提供了set方法，在set方法上添加@value(“值”);

    @Component("user")
public class User {

   public String name;

   @Value("小明")
   public void setName(String name) {
       this.name = name;
  }
}

衍生注解

@Component三个衍生注解

为了更好的进行分层，Spring可以使用其它三个注解，功能一样，目前使用哪一个功能都一样。

  • @Controller：web层
  • @Service：service层
  • @Repository：dao层

写上这些注解，就相当于将这个类交给Spring管理装配了！

作用域

@scope

  • singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂 ，所有的对象都会销毁。
  • prototype：多例模式。关闭工厂 ，所有的对象不会销毁。内部的垃圾回收机制会回收
@Controller("user")
@Scope("prototype")
public class User {
   @Value("小明")
   public String name;
}

小结

XML与注解比较

  • XML可以适用任何场景 ，结构清晰，维护方便
  • 注解不是自己提供的类使用不了，开发简单方便

xml与注解整合开发 ：推荐最佳实践

  • xml管理Bean
  • 注解完成属性注入
  • 使用过程中， 可以不用扫描，扫描是为了类上的注解
<context:annotation-config/>

作用：

  • 进行注解驱动注册，从而使注解生效
  • 用于激活那些已经在spring容器里注册过的bean上面的注解，也就是显示的向Spring注册
  • 如果不扫描包，就需要手动配置bean
  • 如果不加注解驱动，则注入的值为null！

基于Java类进行配置

JavaConfig 原来是 Spring 的一个子项目，它通过 Java 类的方式提供 Bean 的定义信息，在 Spring4 的版本， JavaConfig 已正式成为 Spring4 的核心功能 。

测试：

1、编写一个实体类，Dog

@Component  //将这个类标注为Spring的一个组件，放到容器中！
public class Dog {
   public String name = "dog";
}

2、新建一个config配置包，编写一个MyConfig配置类

@Configuration  //代表这是一个配置类
public class MyConfig {
   @Bean //通过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id！
   public Dog dog(){
       return new Dog();
  }
}

3、测试

@Test
public void test(){
   ApplicationContext applicationContext =
           new AnnotationConfigApplicationContext(MyConfig.class);
   Dog dog = (Dog) applicationContext.getBean("dog");
   System.out.println(dog.name);
}

如何导入其他配置如何做呢？

@Configuration  //代表这是一个配置类
public class MyConfig2 {
}

@Configuration
@Import(MyConfig2.class)  //导入合并其他配置类，类似于配置文件中的 inculde 标签
public class MyConfig {

   @Bean
   public Dog dog(){
       return new Dog();
  }

}

AOP

代理模式：AOP的底层机制就是动态代理！

代理模式分类：

  • 静态代理
  • 动态代理

静态代理

静态代理角色分析

  • 抽象角色 : 一般使用接口或者抽象类来实现
  • 真实角色 : 被代理的角色
  • 代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作
  • 客户 : 使用代理角色来进行一些操作

静态代理的好处:

  • 可以使得我们的真实角色更加纯粹 ，不再去关注一些公共的事情
  • 公共的业务由代理来完成，实现了业务的分工
  • 公共业务发生扩展时变得更加集中和方便

缺点 :

  • 类多了 , 多了代理类 , 工作量变大了 . 开发效率降低 .

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

动态代理

  • 动态代理的角色和静态代理的一样 .

  • 动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的

  • 动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理

    • 基于接口的动态代理----JDK动态代理
    • 基于类的动态代理–cglib
    • 现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist
    • 我们这里使用JDK的原生代码来实现，其余的道理都是一样的！、

JDK的动态代理需要了解两个类

核心：一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类，代理的是接口！

动态代理的好处

静态代理有的它都有，静态代理没有的，它也有！

  • 可以使得我们的真实角色更加纯粹 ，不再去关注一些公共的事情。
  • 公共的业务由代理来完成，实现了业务的分工。
  • 公共业务发生扩展时变得更加集中和方便 。
  • 一个动态代理 , 一般代理某一类业务
  • 一个动态代理可以代理多个类，代理的是接口！

什么是AOP

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

在这里插入图片描述

Spring AOP的实现依赖于动态代理技术。动态代理是在运行时动态生成代理对象，而不是在编译时。它允许开发者在运行时指定要代理的接口和行为，从而实现在不修改源码的情况下增强方法的功能。

AOP实现的注解？

  • @Aspect：用于定义切面，标注在切面类上。
  • @Pointcut：定义切点，标注在方法上，用于指定连接点。
  • @Before：在方法执行之前执行通知。
  • @After：在方法执行之后执行通知。
  • @Around：在方法执行前后都执行通知。
  • @AfterReturning：在方法执行后返回结果后执行通知。
  • @AfterThrowing：在方法抛出异常后执行通知。
  • @Advice：通用的通知类型，可以替代@Before、@After等。

Aop常见的通知类型

Before（前置通知）：目标对象的方法调用之前触发

After （后置通知）：目标对象的方法调用之后触发

AfterReturning（返回通知）：目标对象的方法调用完成，在返回结果值之后触发

AfterThrowing（异常通知）：目标对象的方法运行中抛出 / 触发异常后触发。AfterReturning 和 AfterThrowing 两者互斥。如果方法调用成功无异常，则会有返回值；如果方法抛出了异常，则不会有返回值。

Around （环绕通知）：编程式控制目标对象的方法调用。环绕通知是所有通知类型中可操作范围最大的一种，因为它可以直接拿到目标对象，以及要执行的方法，所以环绕通知可以任意的在目标对象的方法调用前后搞事，甚至不调用目标对象的方法

AOP 切面编程涉及到的一些专业术语：

术语含义
目标(Target)被通知的对象
代理(Proxy)向目标对象应用通知之后创建的代理对象
连接点(JoinPoint)目标对象的所属类中，定义的所有方法均为连接点
切入点(Pointcut)被切面拦截 / 增强的连接点（切入点一定是连接点，连接点不一定是切入点）
通知(Advice)增强的逻辑 / 代码，也即拦截到目标对象的连接点之后要做的事情
切面(Aspect)切入点(Pointcut)+通知(Advice)
Weaving(织入)将通知应用到目标对象，进而生成代理对象的过程动作

声明式事务

Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

  • 声明式事务：AOP

    将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。

    将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

  • 编程式事务：需要在代码中进行事务的管理

    将事务管理代码嵌到业务方法中来控制事务的提交和回滚

    缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码

事务管理器

  • 无论使用Spring的哪种事务管理策略（编程式或者声明式）事务管理器都是必须的。
  • 就是 Spring的核心事务管理抽象，管理封装了一组独立于技术的方法。
Spring(Java框架学习超详细)
blotemj.blog.youkuaiyun.com
04-26 291
Spring 简介 轻量级开源Java开发框架 解决企业级应用开发业务逻辑层和其他各层的耦合问题 体系结构： 核心容器 Spring-core模块：控制反转、依赖注入功能 Spring-beans模块：工厂模式，管理对象：Bean Spring-context模块：访问定义和配置的任何对象的媒介，对象访问方式 Spring-context-support模块：支持高速缓存和任务调度 Spring-expression模块：运行时查询和操作对象 AOP和Instrumentation Spr
Java定时任务实现方案(四)——Spring Task
2301_79318558的博客
01-27 2172
Java定时任务实现方案(四)——Spring Task
Java学习之Spring
chenkaifang的博客
07-08 464
1、Spring的核心：依赖注入（dependency injection，DI）和面向切面编程（aspect-oriented programming，AOP）。Spring的目标就是简化Java开发，通过DI，对象的依赖关系将由系统中负责协调各对象的第三方组件在创建对象的时候进行设定，对象无需自行创建或管理他们的依赖关系。...
Java后端学习系列（8）：Spring框架基础入门
最新发布
Azperk的博客
03-19 557
Spring是一个开源的、轻量级的Java开发框架，它致力于解决企业级应用开发中的复杂性问题，通过提供一系列的功能模块和设计模式，帮助开发者更轻松地构建出高质量、可维护且易于扩展的Java应用程序。它采用了控制反转（IoC）和面向切面编程（AOP）等核心思想，改变了传统Java应用的开发方式，让代码的依赖关系更加清晰，模块之间的耦合度更低。
Java学习-Spring
weixin_44603382的博客
11-20 983
文章目录1、Spring1.1 、简介1.2优点1.3、组成1.4、拓展2、IOC2.1、IOC理论推导2.2、IOC本质3、HelloSpring4、IoC创建对象的方式5、Spring配置5.1别名（alias）5.2、Bean的配置5.3、import6、依赖注入（DI）6.1、构造器注入6.2、Set方式注入【重点】6.3、拓展方式注入6.4Bean的作用域7、Bean的自动装配7.1、测试7.2、byName自动装配7.3、byType自动装配7.4、实现自动装配8、使用注解开发9、使用Java方
java spring怎么学_Java之Spring学习
weixin_35749786的博客
02-13 307
1. 首先知道Spring是个什么.Spring是分层的一个轻量级开源框架. 以反转控制IOC, 和面向切面变成AOP为内核. 提供了展现层spring MVC, 持久层Spring JDBC以及业务层事务管理等众多企业级应用技术.Spring一直贯彻并遵守:好的设计优于具体实现, 代码应该易于测试. 所以Spring提供了IOC容器, 将对象之间的依赖关系交给spring来控制,避免硬编码造成了...
Java框架学习之Spring
天涯屐痕的博客
08-17 783
  什么是spring Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 ...
基于Spring Cloud架构的Java微服务设计源码——spring-cloud-fast
10-05
“基于Spring Cloud架构的Java微服务设计源码——spring-cloud-fast”项目为Java开发者提供了一个很好的学习和实践微服务的平台。通过该项目，开发者能够深入了解Spring Cloud的强大功能，掌握如何高效构建和管理...
Java EE 框架整合开发⼊⻔到实战——Spring+Spring MVC+MyBatis（微课版）课后习题答案.pdf
06-18
这份文档名为《Java EE 框架整合开发入门到实战——Spring+Spring MVC+MyBatis（微课版）课后习题答案.pdf》，它显然是关于Java EE中流行的三个框架整合使用的教程。这三个框架分别是Spring、Spring MVC和MyBatis，...
Java面试题系列——Spring 示例代码.zip
01-02
【一线互联网大厂Java核心面试题库】Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等..
Java全能学习面试手册——Java面试题库.zip
10-01
Java全能学习面试手册——Java面试题库.zip 01 7道消息队列ActiveMQ面试题！.pdf 02 10道Java高级必备的Netty面试题！.pdf 03 10道Java面试必备的设计模式面试题！.pdf 04 10个Java经典的List面试题！.pdf 05 10个...
Spring 学习笔记
m0_50559891的博客
04-15 275
Spring 学习笔记感恩开源Spring特点IOCIOC底层原理如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 感恩开源 跟着尚硅谷的Spring视频过了一遍Spring,虽然有课上笔记，可不自己再总结一下，就感觉记不住。 再次感谢！ Spring Spring框架是
Java之Spring学习笔记
MRS_jianai的博客
11-30 405
Java spring学习笔记
【Java Spring整体学习】整理Spring知识点
m0_46638350的博客
02-27 2082
基本类型注册@Datasetter方法注入：property的name属性，填写的不是属性的名称，而是set方法去除set，然后将第一个字符小写后的结果--1. 普通注入--> < property name = " name " value = " 狂神说 " />
SSM | Spring
weixin_42054526的博客
10-18 1144
SSM | Spring11.Spring介绍1.1 简介1.2 优缺点1.3 组成1.4 拓展2.IOC理论推导3.HelloSpring4.IOC创建对象的方式5.Spring配置6.依赖注入7.Bean的自动装配8.使用注解开发9.使用Java的方式配置Spring 1.Spring介绍 1.1 简介 Spring：给软件行业带来了春天！ 2002，首次推出了Spring框架的雏形：...
Java框架学习--Spring
qq_42803467的博客
06-11 821
容器是用来容纳各种物品的（基本）装置。--来自百度百科之前常见的容器有：List/Map-》数据存储容器Tomcat-》Web容器。
JAVA框架Spring 全面详解（学习总结）
淡若清风
02-13 4282
Spring 1.Spring 全面详解 1.1简介 ◆ Spring：春天 给软件行业带来了春天 ◆ 2002，首次推出了Spring框架的雏形：interface21框架 ◆ Spring框架即是以interface21框架为基础经过重新设计，并不断丰富其内涵，于2004年3月24日发布了1.0正式版 ◆ Rod Johnson Spring Framework创始人，著名作者。 Rod在悉尼大学不仅获得了计算机学位，同时还获得了音乐学位。更令人吃惊的是在回到软件开发领域之前，他还获得了音乐学的博士学位
Java spring详解 （学习总结）
Garson的博客
10-02 310
JavaSpring框架入门详解，包含配置xml、maven到IOC、AOP和Spring实现的底层原理。
java学习之spring基础
l688899886的博客
06-29 244
spring框架应用的是ioc模式，ioc模式是指控制反转模式，本质是你不去创建对象让spring框架给你创建对象你去使用对象。多种开发模式通过配置文件和注解的方式去开发的都很值得去学习构造一个接口 如果按照平时开发的思路这个时候会去写一个test类去创建mssqldaodimpl、mysqldaoimpl去构建对象然后去执行两个的select方法如果是在spring里面就会用ioc这种方式，这两个类都是ioc容器里面的两个bean只需要通过spring的模式去访问他们先写配置文件 id
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值