Spring（一）

最新推荐文章于 2024-07-14 19:12:40 发布
最新推荐文章于 2024-07-14 19:12:40 发布
阅读量337 收藏 3
点赞数 5
分类专栏： Spring 文章标签： spring android java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46589153/article/details/140004331
版权

Spring简介

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

API文档

帮助文档

IOC

在这里插入图片描述

  1. new对象实现操作

    • UserServiceImpl

      public class UserServiceImpl implements UserService{
    private UserDao userDao = new UserDaoImpl();
   
    @Override
    public void execute() {
        userDao.execute();
    }
}

    在通过new对象调用Dao层的方法时，处理逻辑在业务层，如果之后需要修改实现的dao层方法时必须在业务层进行修改，违背了开闭原则。所以引入了下面的用set接口来得到dao层的对象。

  2. 通过set接口实现

    • UserDaoImpl

      public class UserDaoImpl implements UserDao{
    @Override
    public void execute() {
        System.out.println("MySQL 执行");
    }
}

    • UserDao

      public interface UserDao {
    void execute();
}

    • UserServiceImpl

      public class UserServiceImpl implements UserService{
    private UserDao userDao;
    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }
    @Override
    public void execute() {
        userDao.execute();
    }
}

    • UserService

      public interface UserService {
    void execute();
}

    • Test

      @Test
public void test(){
    UserService userService = new UserServiceImpl();
    UserDao userDao = new UserDaoImpl();
    ((UserServiceImpl)userService).setUserDao(userDao);
    userService.execute();
}

    使用set注入之后，业务层不再担任创建对象的角色，程序不再有主动性，而是将该功能抛给了上一层，将控制权交给了用户。用户想怎么调用，调用哪类的方法，仅需在上一层完成即可。

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

  1. IOC本质

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

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

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

Hello实例

  1. 实体类

    public class Hello {
    private String str;
    public String getStr() {
        return str;
    }
    public void setStr(String str) {
        this.str = str;
    }
    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

  2. ApplicationContext.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">

<!--
    用spring来创建对象，在spring这些都成为bean
    类型 变量名 = new 类型();
    Hello hello = new Hello();

    id = 变量名
    class = new 的对象
    property 相当于给对象中的属性设置一个值
    value 设置值
    ref 设置嵌套的bean
-->
    <bean id="hello" class="org.example.pojo.Hello">
        <property name="str" value="spring"/>
    </bean>

</beans>

  3. 测试

     @org.junit.Test
    public void test(){
//        获取spring的的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//        我们的对象都在spring中管理，从中取出即可
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello);
    }

  4. 思考：

    • Hello对象是谁创建的？

      Hello对象是由Spring创建的。

    • Hello对象的属性是怎么设置的？

      Hello对象的属性是由Spring容器设置的。

这个过程就叫控制反转：

控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。

反转：程序本身不创建对象，而变成被动的接收对象。

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

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

可以通过new ClassPathXmlApplicationContext去浏览一下底层源码。

到了现在，不用在程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的IOC，一句话搞定：对象由Spring来创建，管理，装配！

IOC创建对象的方式

  1. 默认情况下bean通过无参构造方法进行创建

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

  2. 在写了有参构造方法之后，多个参数需要使用下列方式进行创建bean

    • 通过下标创建

      <bean id="user" class="org.example.pojo.User">
    <constructor-arg index="0" value="xxxyyy"/>
</bean>

    • 通过类型创建

      <!--通过类型-->
<bean id="user" class="org.example.pojo.User">
    <constructor-arg type="java.lang.String" value="xxxyy"/>
</bean>

    • 通过参数名创建

      <!--参数名-->
<bean id="user" class="org.example.pojo.User">
    <constructor-arg name="name" value="xxxyy"/>
</bean>

Spring配置

  1. 别名

    <bean id="user" class="org.example.pojo.User" name = "user2,u2">
    <constructor-arg name="name" value="xxxyy"/>
</bean>
<alias name="user" alias="user2"/>

    name也可以设置别名，还可以同时设置多个。

  2. import

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

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

依赖注入

  1. 构造器注入

  2. Set方式注入重点

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

  3. Address实体类

    public class Address {
    private String address;//省略get set
}

  4. Student实体类

    package org.example.pojo;

import java.util.*;

public class Student {
        private String name;
        private Address address;
    	private String[] books;
        private List<String> hobbies;
        private Map<String,String> card;
        private Set<String> games;
        private String wife;
        private Properties info;
    //省略get set
}

  5. 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">

    <!--
        用spring来创建对象，在spring这些都成为bean
        类型 变量名 = new 类型();
        Hello hello = new Hello();

        id = 变量名
        class = new 的对象
        property 相当于给对象中的属性设置一个值
        value 设置值
        ref 设置嵌套的bean
    -->
    <bean id="student" class="org.example.pojo.Student">
        <!--        普通注入value       -->
        <property name="name" value="xxxxyyy"/>
        <!--        bean注入，ref-->
        <property name="address" ref="address"/>
        <!--        数组      -->
        <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>
            </list>
        </property>
        <!--        map     -->
        <property name="card">
            <map>
                <entry key="身份证" value="14321321"/>
                <entry key="电话" value="132545461"/>
            </map>
        </property>

        <!--        set     -->
        <property name="games">
            <set>
                <value>cf</value>
                <value>lol</value>
                <value>csgo</value>
            </set>
        </property>
        <!--        空值      -->
        <property name="wife">
            <null/>
        </property>

        <!--        properties      -->
        <property name="info">
            <props>
                <prop key="学号">201855555</prop>
                <prop key="性别">男</prop>
            </props>
        </property>
    </bean>

    <bean id="address" class="org.example.pojo.Address">
        <property name="address" value="西安"/>
    </bean>
</beans>

P标签和C标签

p命名空间本质还是setter注入，c命名空间本质还是构造器注入

  • p命名空间：用于简化XML配置文件中的property标签，即setter注入。对于每一个需要注入的属性，我们通常需要创建一个<property>标签来配置它。当一个bean有大量的属性需要注入时，XML文件可能会变得臃肿和难以管理。这时，我们可以使用p命名空间，它允许我们在<bean>标签中直接配置property注入。
  • c命名空间：用于简化XML配置文件中的constructor-arg标签，即构造器注入。传统的构造器注入需要为每一个需要注入的构造器参数创建一个<constructor-arg>标签。当一个bean有大量的构造器参数时，配置也可能会变得很大。c命名空间解决了这个问题，它允许我们在<bean>标签中直接配置构造器注入。

举个例子，传统的setter注入和使用p命名空间的setter注入：

<!-- 传统的setter注入 -->
<bean id="exampleBean" class="examples.ExampleBean">
  <property name="email" value="example@example.com" />
</bean>

<!-- 使用 p 命名空间的 setter 注入 -->
<bean id="exampleBean" class="examples.ExampleBean" 
  p:email="example@example.com" />

同样地，传统的构造器注入和使用c命名空间的构造器注入：

<!-- 传统的构造器注入 -->
<bean id="exampleBean" class="examples.ExampleBean">
  <constructor-arg type="int" value="10" />
  <constructor-arg type="int" value="20" />
</bean>

<!-- 使用 c 命名空间的构造器注入 -->
<bean id="exampleBean" class="examples.ExampleBean"
  c:arg1="10" c:arg2="20"/>

最后需要注意的是，使用p或c命名空间需要在XML文件的顶部声明对应的XML架构：

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

作用域

ScopeDescription
singleton(Default) Scopes a single bean definition to a single object instance for each Spring IoC container.
prototypeScopes a single bean definition to any number of object instances.
requestScopes a single bean definition to the lifecycle of a single HTTP request. That is, each HTTP request has its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.
sessionScopes a single bean definition to the lifecycle of an HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.
applicationScopes a single bean definition to the lifecycle of a ServletContext. Only valid in the context of a web-aware Spring ApplicationContext.
websocketScopes a single bean definition to the lifecycle of a WebSocket. Only valid in the context of a web-aware Spring ApplicationContext.

  1. 单例模式(spring默认机制)

    <bean id="accountService" class="com.something.DefaultAccountService"/>

<!-- the following is equivalent, though redundant (singleton scope is the default) -->
<bean id="accountService" class="com.something.DefaultAccountService" scope="singleton"/>

在这里插入图片描述

  1. 原型模式(每次从容器中get都是一个新对象)

    <bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>

    在这里插入图片描述

  2. 其余的只能在web开发中使用。

Bean的自动装配

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

在Spring 中有三种装配的方式

  1. 在xml 中显示的配置
  2. 在java中显示配置
  3. 隐式 的自动装配bean【重要】
<!--    显示配置        -->
<bean id="cat" class="org.example.pojo.Cat"/>
<bean id="dog" class="org.example.pojo.Dog"/>

<bean id="people" class="org.example.pojo.People">
    <property name="name" value="xxxyyy"/>
    <property name="cat" ref="cat"/>
    <property name="dog" ref="dog"/>
</bean>

ByName方法自动装配

  1. autowire=“byName”
  2. 会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id！
  3. 弊端：set 方法后面的值和 id 相同
<bean id="cat" class="cn.bloghut.domin.Cat"/>
<bean id="dog" class="cn.bloghut.domin.Dog"/>

<!--
    byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id！
-->
<bean id="people" class="org.example.pojo.People" autowire="byName">
    <property name="name" value="xxxyy"/>
</bean>

  1. autowire=“byType”

  2. 会自动在容器上下文中查找，和自己对象属性类型相同的bean

  3. 弊端：它必须保证类型全局唯一（在IOC容器中只能由一个）。

    <bean id="cat" class="cn.bloghut.domin.Cat"/>
<bean id="dog11" class="cn.bloghut.domin.Dog"/>
   <!--
    byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean

-->
  <bean id="people" class="rg.example.pojo.People" autowire="byType">
      <property name="name" value="xxxyy"/>
  </bean>

总结：

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

注解实现自动装配

  1. 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"
	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>

  1. @Autowired

    • 在属性上使用

    • 在set方式上使用

    • 使用Autowired 可以不用编写set方法了，前提是你这个自动装配的属性在IOC（Spring）容器中存在（需要通过其他方式注入进容器），且符合名字byType。

    • 默认情况下是 byType，如果byType无法装配，那么可以使用 @Qualifier 进行 byName 装配。

public class People {
    @Autowired
    private Dog dog;
    
    @Autowired
    private Cat cat;
    private String name;

    public People() {
    }

    public People(Dog dog, Cat cat, String name) {
        this.dog = dog;
        this.cat = cat;
        this.name = name;
    }
}

  1. @Nullable

    • 字段标记了这个注解，表示这个字段可以为null

  2. @Qualifier

    • 当我们的容器存在多个相同类型，不同名称的bean。使用@Autowired 无法完成自动装配了
    • 这个时候需要使用@Qualifier 和@Autowired 注解一起使用。
    • 使用@Qualifier 指定一个唯一的bean对象注入！
      例如

  3. @Resource

    @Resource注解的装配顺序稍有不同。它首先会按照byName方式进行查找装配，如果没有找到匹配的bean，再按照byType方式进行装配。如果还是没有找到，就会抛出异常。

    这里是一个简化的装配规则总结：

    • @Autowired: 默认按照byType方式进行查找装配。
    • @Resource: 默认按照byName方式进行查找装配，如果找不到，则按照byType方式进行装配。如果都找不到，就会抛出异常。

Spring注解开发

  1. 使用注解需要导入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
		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:component-scan base-package="org.example"/>

</beans>

    bean注入使用**@Componet注解等价**于

    <bean id="user" class="org.example.pojo.User">

  2. 注入属性用@Value

    // xml文件写法：	<property name="name" value="xxxyy">
@Component
public class User {

    private String name;

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

    衍生注解

    • @Componet有几个衍生注解，在web开发中，会按照mvc三层架构分层！
    • @Service--------业务层注解
    • @Repository—持久层注解
    • @Controller-----控制层注解

    作用域

    @Scope(“singleton”)单例

  3. 总结

    XML 与 注解

    • xml更加万能，适用于任何场合！维护简单方便
    • 注解不是自己类使用不了， 维护相对复杂

    XML 与 注解最佳实践

    • xml用来管理bean
    • 注解只负责完成属性的注入
    • 我们在使用过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持
    <!--开启注解扫描-->
<context:component-scan base-package="org.example"/>

<!--开启注解支持-->
<context:annotation-config/>

Java的方式配置及Spring

JavaConfig 是Spring的 一个子项目，在Spring 4之后，它成为了新功能

  1. 首先定义一个类，在类上添加@Component注解，让它加载到Spring IOC容器（让Spring 管理）

    • AppConfig类
    /*
* @Configuration 这个也是Spring容器托管，注册到容器中，因为他本来就是一个Component
* @Configuration 代表这是一个配置类，就和我们之前的beans.xml一样
* */
@Configuration
@ComponentScan("org.example")
//@Import(AppConfig.class)  可以引入其他的配置类
public class AppConfig {
/*
* @Bean 注册一个bean，相当于之前写的bean标签
* 方法名相当于标签中的id属性
* 方法的返回值相当于bean标签中的class属性
* */
    @Bean
    public User getUser(){
        return new User();  //返回要注入到bean中的对象
    }
}

    • 实体类

      @Component
public class User {
    @Value("xxxyy")
    private String name;

    public String getName() {
        return name;
    }

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

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

    • 测试方法

      public static void main(String[] args) {
//        如果完全使用了配置类的方式去做，我们就只能通过 AnnotationConfig 上下文来获取容器，通过配置类的class对象加载
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        User getUser = context.getBean("getUser", User.class);
        System.out.println(getUser);
    }

  2. 定义Java 配置类，在其类上添加@Configuration 注解，说明该类是一个配置类，这个类也会被Spring 托管，因为它本身是一个@Component

  3. 在AppConfig 类中 添加getUser 方法，返回一个user对象
    getUser 方法上的@Bean 注解 则是注册一个bean功能，相当于

<bean id="getUser" class="cn.bloghut.domain.User">

代理模式

静态代理

  1. 抽象角色：一般会使用接口或者抽象类来解决
  2. 真实角色：被代理的角色
  3. 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
  4. 客户：访问代理对象的人

优势

  1. 可以使真实角色的操作更加存粹！不用去关注一些公共的业务
  2. 公共交给了代理角色，实现了业务的分工
  3. 公共业务发生扩展的时候，方便集中管理

缺点

  1. 一个真实角色就会产生一个代理角色，代码量会翻倍 开发效率变低

租房例子（静态代理）

在这里插入图片描述

public interface Rent {
    void rent();
}

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

public class Proxy implements Rent{

    private Host host;
    public Proxy(){
    }
    
    public Proxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        fare();
        heTong();
    }
    public void seeHouse(){
        System.out.println("中介带你看房子");
    }
    public void fare(){
        System.out.println("中介收取费用！");
    }
    public void heTong(){
        System.out.println("中介签署合同");
    }
}

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

新增日志输出（静态代理）

  1. 有一天，公司领导要求我为 某个类的所有方法新增日志输出功能。
  2. 怎么做呢？
  3. 在原来的类上的每一个方法添加日志输出？
  4. 这就是改变原来人家的代码了。
  5. 改动原有的业务代码，在公司中是大忌！
  6. 有可能人家你修改了人家的代码，可能给改蹦了。
  7. 新增一个类，制作成本小，职责单一。

在这里插入图片描述

public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}

public class UserServiceImpl implements UserService {
    @Override
    public void add() {
        System.out.println("新增用户");
    }

    @Override
    public void delete() {
        System.out.println("删除用户");
    }

    @Override
    public void update() {
        System.out.println("修改用户");
    }

    @Override
    public void query() {
        System.out.println("查询用户");
    }
}

public class UserProxy implements UserService{
    private UserService userService;

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    @Override
    public void add() {
        log("add");
        userService.add();
    }

    @Override
    public void delete() {
        log("delete");
        userService.delete();
    }

    @Override
    public void update() {
        log("update");
        userService.update();
    }

    @Override
    public void query() {
        log("query");
        userService.query();
    }

    public void log(String message){
        System.out.println("[debug]使用了："+message+"方法");
    }
}

public static void main(String[] args) {
    UserProxy userProxy = new UserProxy();
    userProxy.setUserService(new UserServiceImpl());
    userProxy.add();
}

动态代理

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

  • 动态代理的代理类是动态生成的，不是我们直接写好的

  • 动态代理分为两大类：基于接口的动态代理，基于类的动态代理

  • 基于接口：JDK动态代理

  • 基于类：

    • cglib

    • java字节码实现： javasist

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

Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。(大白话：这是一个静态类，类里边有方法得到代理类)

动态代理类 （以下简称为代理类 ）是一个实现在类创建时在运行时指定的接口列表的类，具有如下所述的行为。 代理接口是由代理类实现的接口。 代理实例是代理类的一个实例。 每个代理实例都有一个关联的调用处理程序对象，它实现了接口

通过其代理接口之一的代理实例上的方法调用将被分派到实例调用处理程序的invoke方法，传递代理实例， java.lang.reflect.Method被调用方法的java.lang.reflect.Method对象以及包含参数的类型Object Object的数组。 调用处理程序适当地处理编码方法调用，并且返回的结果将作为方法在代理实例上调用的结果返回。

代理类具有以下属性：

  • 代理类是公共的，最终的，而不是抽象的，如果所有代理接口都是公共的。
  • 如果任何代理接口是非公开的，代理类是非公开的，最终的，而不是抽象的 。
  • 代理类的不合格名称未指定。 然而，以字符串"$Proxy"开头的类名空间应该保留给代理类。
  • 一个代理类扩展了java.lang.reflect.Proxy 。
  • 代理类完全按照相同的顺序实现其创建时指定的接口。
  • 如果一个代理类实现一个非公共接口，那么它将被定义在与该接口相同的包中。 否则，代理类的包也是未指定的。 请注意，程序包密封不会阻止在运行时在特定程序包中成功定义代理类，并且类也不会由同一类加载器定义，并且与特定签名者具有相同的包。
  • 由于代理类实现了在其创建时指定的所有接口， getInterfaces在其类对象上调用getInterfaces将返回一个包含相同列表接口的数组（按其创建时指定的顺序），在其类对象上调用getMethods将返回一个数组的方法对象，其中包括这些接口中的所有方法，并调用getMethod将在代理接口中找到可以预期的方法。
  • Proxy.isProxyClass方法将返回true，如果它通过代理类 - 由Proxy.getProxyClass返回的类或由Proxy.newProxyInstance返回的对象的类 - 否则为false。
  • 所述java.security.ProtectionDomain代理类的是相同由引导类装载程序装载系统类，如java.lang.Object ，因为是由受信任的系统代码生成代理类的代码。 此保护域通常将被授予java.security.AllPermission 。
  • 每个代理类有一个公共构造一个参数，该接口的实现InvocationHandler ，设置调用处理程序的代理实例。 而不必使用反射API来访问公共构造函数，也可以通过调用Proxy.newProxyInstance方法来创建代理实例，该方法将调用Proxy.getProxyClass的操作与调用处理程序一起调用构造函数。

实例

public interface Rent {
    void rent();
}

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

public class ProxyInvocationHandler implements InvocationHandler {
//    被代理的接口
    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }
//    生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(),this);
    }
    /*
    * 处理代理实例返回结果
    * @param proxy
    * @param method
    * @param args
    * @return
    * */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//        动态代理的本质就是使用反射机制
//        在方法调用前调用
        seeHouse();
        Object result = method.invoke(rent, args);
        heTong();
        return result;
    }
    public void seeHouse(){
        System.out.println("看房子");
    }
    public void heTong(){
        System.out.println("签合同");
    }
}

public static void main(String[] args) {
            //创建真实角色
            Host host = new Host();
            //创建代理角色不存在
            ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
            //设置要代理的对象
            proxyInvocationHandler.setRent(host);
            //获取代理对象，并强制转换
            Rent proxy = (Rent)proxyInvocationHandler.getProxy();
            //调用
            proxy.rent();
}

通用执行代码

public class ProxyInvocationHandler implements InvocationHandler {
        //1.被代理的接口
        public Object target;

        public void  setTarget(Object target){
            this.target = target;
        }

        //2.生成得到代理类（代理谁）
        public Object getProxy(){
            return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                    target.getClass().getInterfaces(),this);
        }

        //3.处理代理实例，并返回结果（代用代理程序）
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //动态获取方法名称
            log(method.getName());
            Object result = method.invoke(target, args);
            return result;
        }
        /**
         * 打印日志方法
         * @param msg
         */
        public void log(String msg){
            System.out.println("[debug]===> 执行可"+msg+"方法");
        }
}

小结

静态代理

  1. 由程序员创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了
  2. 静态代理通常只代理一个类
  3. 静态代理事先知道要代理的是什么

动态代理

  1. 在程序运行时，运用反射机制动态创建而成
  2. 动态代理是代理一个接口下的多个实现类
  3. 动态代理不知道要代理什么东西，只有在运行时才知道

​ 与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler接口提供了生成动态代理类的能力。

Freeking1024
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring中文文档下载
09-27
Spring框架是Java开发中的一个核心组件，以其模块化、易用性和灵活性著称。这个压缩包包含Spring的多个中文版本的文档，可以帮助开发者深入理解Spring的功能和使用方法。 `Spring3.0中文版.chm`提供了Spring框架3.0...
spring第一天学习
02-15
spring学习第一天讲义
spring6pdf详细讲解
09-18
Spring 是一个功能强大且功能齐全的 Java 应用程序框架，提供了一个通用的基础结构来支持开发企业级应用程序。 Spring 框架的核心是控制反转（IoC）和依赖注入（DI）模式，它们使得应用程序更加灵活、可维护和可扩展...
springcloud源码
08-13
Spring Cloud 是一个基于 Spring Boot 实现的微服务框架，它为开发者提供了在分布式系统（如配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性令牌、全局锁、领导选举、分布式会话、集群状态）操作的...
Spring例子
03-26
Spring框架是Java开发中的一个核心组件，主要用于简化企业级应用的开发。它提供了一个全面的编程和配置模型，旨在提高生产效率，同时鼓励面向接口的编程和依赖注入（DI）原则。Spring MVC是Spring框架的一个模块，专...
Spring源码(三) Spring IoC之BeanFactory创建bean和获取bean
一生编程，快乐编程
07-11 941
bean 对象主要放在 map 里面，map 作为缓存。map 的key 是 bean对象的名称， value 是 bean 对象或者对象工厂。代码详情见： https://blog.csdn.net/sinat_32502451/article/details/140155044。详情见： https://blog.csdn.net/sinat_32502451/article/details/140247662。根据 bean 名称，返回已经注册的单例对象，如果没有注册，则创建并注册一个新对象。
5.SpringBoot核心源码-启动类源码分析
流月up的博客
07-12 383
SpringBoot核心源码-启动类源码分析
elk部署springboot
Chihirozy的博客
07-11 361
elk部署springboot。
基于SpringBoot构造超简易QQ邮件服务发送 第二版
键盘爱好者
07-09 271
第二版的更新点是追加了 邮箱附件功能 ( 后期追加定时任务 )
基于SpringBoot+MySQL的租房项目+文档
欧阳小白闯天涯
07-11 930
在当今快节奏的生活中，房屋租赁市场的需求与日俱增。为了有效管理租房流程、提升用户体验，本文基于SpringBoot+MySQL技术栈，设计并实现了一套全方位的租房系统。该系统融合了经纪人、维修员、管理员和用户四个角色，各自拥有独特的功能模块，包括房源管理、维修处理、员工用户管理、统计分析等。经纪人角色能够方便地添加房源、管理自己的房源、处理房源出租事务，并通过系统提供的月出租量统计功能进行业绩分析与优化。其次，维修员可以及时响应待处理的房源报修请求，有效地管理已处理的房源维修记录。
在项目中，如何使用springboot+vue+springsecurity+redis缓存+Axios+MySQL数据库+mybatis
huanghm88的专栏
07-11 683
在Spring Boot中，可以使用Spring Data JPA和MyBatis来配置MySQL数据库。在Vue项目中，可以创建一个config.js文件来配置后端的API地址，然后在需要发送请求的地方使用Axios发送请求。根据业务需求，在Spring Boot中编写相应的接口和服务层代码，包括数据访问、业务逻辑等。在Vue中，可以使用Axios发送HTTP请求，并将响应的数据展示在前端页面上。分别启动后端的Spring Boot应用和前端的Vue应用，访问前端页面，就可以看到与后端进行通信的效果。
springboot系列教程（二）：Log4j2日志信息（含源码）
weixin_43860634的博客
07-14 780
springboot系列教程（二）：Log4j2日志信息（含源码）
Spring常见问题一：IOC和DI
最新发布
Jeremy程序员
07-14 439
控制反转（Inversion of Control，IoC）和依赖注入（Dependency Injection，DI）是现代软件开发中的关键设计原则。IoC通过将对象的创建和依赖管理交给容器，实现模块解耦和代码可维护性。DI作为IoC的实现方式，通过构造函数、Setter方法和接口注入增强模块化和代码可读性。依赖关系如果处理不当，会导致高耦合、代码重用性低等问题。Spring框架通过IoC容器支持依赖注入，管理对象生命周期和依赖关系，提供多种注入方式、配置方式和作用域管理，使代码更加模块化、可维护和易于测
【JavaEE】Spring AOP详解
m0_74105656的博客
07-10 866
SpringAOP知识点的详细讲解
Spring AOP的几种实现方式
weixin_69039908的博客
07-10 437
1.1导入依赖1.2定义注解1.2定义切面类。
springboot中通过jwt令牌校验以及前端token请求头进行登录拦截实战
weixin_73355042的博客
07-10 1646
Slf4j@Autowired/*** 注册自定义拦截器*/log.info("开始注册自定义拦截器...");.addPathPatterns("/user/**") //表示拦截所以前缀带/user的请求//排除特定路径：excludePathPatterns("/user/login") 方法用于排除某些路径，//即使它们匹配前面指定的模式。在这个例子中，/user/login 路径不会被 jwtTokenAdminInterceptor 拦截。/*** 设置静态资源映射。
springboot 事务加载过程
jim_007的博客
07-10 301
原文链接：https://blog.csdn.net/qq_59622162/article/details/131701823。2、springBoot 创建事务。3、springBoot 执行事务。
2.快速搭建 SpringBoot hello world
suhuamo的博客
07-10 441
Spring Boot 2.6.1 需要Java 8，并且与Java 15（包括）兼容。还需要Spring Framework 5.2.10.RELEASE或 更高版本。
【思考Spring Security框架的相关问题】
qq_56949201的博客
07-10 280
答:，会返回Authentication接口类型的对象,本质上是UsernamePasswordAuthenticationToken类型,此类型中的pricipal属性就是通过认证的用户信息。并且从中获取用户信息，用于创建认证对象，最后，将认证对象存入到SecurityContext中，剩下的就可以交由框架进行处理了，例如判断是否已经通过认证等。配置请求认证的过程中，调用的mvcMatchers()方法的作用是什么？配置请求认证的过程中，调用的permitAll()方法的作用是什么？
新建一个 spring项目
06-12
好的，下面是创建 Spring 项目的步骤： 1. 打开 Eclipse IDE，选择 "File" -> "New" -> "Other..."。 2. 在弹出的 "New" 窗口中，选择 "Spring" -> "Spring Starter Project"。 3. 在 "New Spring Starter Project" 窗口中，填写以下信息： - 项目名称：输入你想要命名的项目名称。 - 项目类型：选择 Maven 或 Gradle。 - Group：输入你的组织名称，例如 com.example。 - Artifact：输入你的项目名称，例如 spring-demo。 - Description：输入你的项目描述，例如 "My first Spring project"。 - Package：输入你的项目包名，例如 com.example.springdemo。 4. 点击 "Next"，在 "Dependencies" 选项卡中选择你想要的 Spring Starter 依赖项。例如，选择 "Spring Web" 依赖项可以创建一个 Web 应用程序。 5. 点击 "Finish"，Eclipse 将自动生成一个基本的 Spring 项目结构。 现在你已经成功创建了一个 Spring 项目。接下来，你可以开始编写代码并运行应用程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值