Spring (二) 注解及代理模式

已于 2024-04-13 20:26:27 修改
阅读量1.2k 收藏 17
点赞数 9
分类专栏： Spring 文章标签： spring 后端
于 2024-04-04 15:33:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45525848/article/details/137375910
版权

在这里插入图片描述

文章目录

一、DI 注解之 Autowired 和 Value 注解（掌握）

1、DI 注解

因为之前 XML 配置方式比较繁琐。

<bean id="person" class="cn.wolfcode._01_hello.Person">
    <property name="name" value="大罗"/>
</bean>

分两类，Spring 的 Autowire，JavaEE 的 Resource，两者作用是一样，完成属性或字段的注入，注入是 bean（取代 XML property ref 元素）。而 Spring 的 Value 注解也是完成属性或字段的注入，注入是常量值（取代 XML property value 元素）。

2、Autowired 注解使用

2.1、编写类

package cn.wolfcode._04_anno;

public class Dog {
	@Value("黄色")
    private String color;
	
	@Override
	public String toString() {
		return "Dog [color=" + color + "]";
	}
}

package cn.wolfcode._04_anno;

public class Person {
	@Autowired
	private Dog dog;

	@Override
	public String toString() {
		return "Person [dog=" + dog + "]";
	}
}

2.2、编写配置文件

在 resources 目录下新建 04.anno.xml，配置如下：

<bean id="dog" class="cn.wolfcode._04_anno.Dog"/>

<bean id="person" class="cn.wolfcode._04_anno.Person"/>

<!-- 配置 DI 注解解析器，但其实可以不配置 -->
<context:annotation-config/>

2.3、编写单元测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:04.anno.xml")
public class PersonTest {
	@Autowired
	private Person person;

	@Test
	public void test() {
		System.out.println(person);
	}
}

3、Autowired 注解细节

  • 可以让 Spring 自动的把属性或字段需要的对象找出来，并注入到属性上或字段上。
  • 可以贴在字段或者 setter 方法上面。
  • 可以同时注入多个对象。
  • 可以注入一些 Spring 内置的重要对象，比如 BeanFactory，ApplicationContext 等。
  • 默认情况下 Autowired 注解必须要能找到对应的对象，否则报错。通过 required=false 来避免这个问题：@Autowired(required=false)。
  • 第三方程序：Spring3.0 之前需要手动配置 Autowired 注解的解析程序：<context:annotation-config/>，在 Spring 的测试环境可以不配置，在 Web 开发中换一种配置解决。
  • Autowired 注解寻找 bean 的方式：
    • 首先按照依赖对象的类型找，若找到，就是用 setter 或者字段直接注入。
    • 如果在 Spring 上下文中找到多个匹配的类型，再按照名字去找，若没有匹配报错。
    • 可以通过使用 @Qualifier(“other”) 标签来规定依赖对象按照 bean 的 id 和 类型的组合方式去找。

二、DI 注解之 Resource 注解（了解）

1、添加依赖

<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>javax.annotation-api</artifactId>
    <version>1.3.2</version>
</dependency>

2、Resource 注解使用

修改上面代码的 Person 类使用 Resource 注解，再重新测试即可。

package cn.wolfcode._04_anno;

public class Person {
	@Resource
	private Dog dog;

	@Override
	public String toString() {
		return "Person [dog=" + dog + "]";
	}
}

3、Resource 注解细节

  • 可以让 Spring 自动的把属性或字段需要的对象找出来，并注入到属性上或字段上。
  • 可以贴在字段或者 setter 方法上面。
  • 可以注入一些 Spring 内置的重要对象，比如 BeanFactory，ApplicationContext 等。
  • Resource 注解必须要能找到对应的对象，否则报错。
  • 第三方程序：Spring3.0 之前需要手动配置 Autowired 注解的解析程序：<context:annotation-config/>，在 Spring 的测试环境可以不配置， Web 开发中换一种配置解决。
  • Resource 注解寻找 bean 的方式：
    • 首先按照名字去找，如果找到，就使用 setter 或者字段注入。
    • 若按照名字找不到，再按照类型去找，但如果找到多个匹配类型，报错。
    • 可以直接使用 name 属性指定 bean 的名称（@Resource(name=“”)）；但若指定的 name，就只能按照 name 去找，若找不到，就不会再按照类型去。

4、Autowired 注解与 Resource 注解选用

都可以，出去后看公司。

三、IoC 注解（掌握）

1、XML 配置问题

Spring 的 XML 配置文件中还有很多 bean 的配置，那能不能让 Spring 通过什么方式来简化配置呢？

<bean id="dog1" class="cn.wolfcode._04_anno.Dog">
    <property name="color" value="黄色"/>
</bean>

<bean id="dog2" class="cn.wolfcode._04_anno.Dog">
    <property name="color" value="黑色"/>
</bean>

2、IoC 注解

四个注解的功能是相同的，只是用于标注不同类型的类上：

  • @Repository：用于标注数据访问组件，即 DAO 实现类上。
  • @Service：用于标注业务层实现类上。
  • @Controller：用于标注控制层类上（如 SpringMVC 的 Controller）。
  • @Component：当不是以上的话，可以使用这个注解进行标注。

3、IoC 注解使用

3.1、修改类

修改上面代码的 Person 类和 Dog 类，使用 Component 注解。

package cn.wolfcode._04_anno;

@Component
public class Dog {
    @Value("黄色")
	private String color;

	@Override
	public String toString() {
		return "Dog [color=" + color + "]";
	}
}

package cn.wolfcode._04_anno;

@Component
public class Person {
	@Autowired
	private Dog dog;

	@Override
	public String toString() {
		return "Person [dog=" + dog + "]";
	}
}

@Component 不写 value 值的话，bean 名字就类名首字母小写，上面列子就是 bean 的名字就是 person。

3.2、修改配置文件

在 04.anno.xml，配置如下：

<!-- 配置注解的第三方程序  解析 IoC 注解 DI 注解，让这些注解起作用-->
<context:component-scan base-package="cn.wolfcode._04_anno"/>

改完配置再测试一下看效果。

四、Scope 和 PostConstruct 以及 PreDestroy 注解（了解）

1、问题

比如之前使用 XML 方式配置 bean 的作用域等能不能也使用注解的方式？

2、注解说明

  • @Scope：贴在类上，标明 bean 的作用域。
  • @PostConstruct：贴在方法上，标明 bean 创建完后调用此方法。
  • @PreDestroy：贴在方法上，标明容器销毁时调用此方法。

3、注解使用

3.1、编写类

package cn.wolfcode._04_anno;

@Component
@Scope("prototype")
public class MyDataSource {
	public MyDataSource() {
		System.out.println("对象创建");
	}
	public void getConnection() {
		System.out.println("拿到连接");
	}
	@PostConstruct
	public void init() {
		System.out.println("初始化池子");
	}
    @PreDestroy
	public void close() {
		System.out.println("销毁池子");
	}
}

3.2、编写配置文件

配置文件内容不变，还是跟上面一样。

3.3、编写单元测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:04.anno.xml")
public class MyDataSourceTest {
	@Autowired
	private MyDataSource dataSource;
	
	@Test
	public void test() {
		dataSource.getConnection();
	}
}

五、练习-使用注解配置模拟学生注册（掌握）

1、拷贝之前 XML 配置的项目

修改 pom.xml 的项目名为 spring-anno-register，再重新导入。

2、修改 DAO 层代码

package cn.wolfcode.dao.impl;

@Repository
public class StudentDAOImpl implements IStudentDAO {
    @Autowired
	private DataSource dataSource;

	@Override
	public void save(String username, String password) throws Exception {
		@Cleanup
		Connection connection = dataSource.getConnection();
		@Cleanup
		PreparedStatement ps = connection.prepareStatement("INSERT INTO student(username, password) VALUES(?, ?)");
		ps.setString(1, username);
		ps.setString(2, password);
		ps.executeUpdate();
	}
}

3、修改业务层代码

package cn.wolfcode.service.impl;

@Service
public class StudentServiceImpl implements IStudentService {
	@Autowired
	private IStudentDAO studentDAO;

	@Override
	public void register(String username, String password) throws Exception {
		studentDAO.save(username, password);
	}
}

4、修改 applicationContext.xml

<!-- 引入 db.properties -->
<context:property-placeholder location="classpath:db.properties"/>

<!-- 配置 DataSource bean -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
    init-method="init" destroy-method="close">
    <property name="driverClassName" value="${jdbc.driverClassName}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

<!-- 配置第三方解析程序，让 IoC DI 注解起作用 -->
<context:component-scan base-package="cn.wolfcode"/>

六、控制事务繁琐（理解）

1、问题

考虑一个应用场景：需要对系统中的某些业务方法做事务管理，拿简单的 save 操作举例。没有加上事务控制的代码如下：

public class EmployeeServiceImpl implements IEmployeeService {
    public void save(Employee employee){
        // 保存业务操作
    }
}

修改源代码，加上事务控制之后：

public class EmployeeServiceImpl implements IEmployeeService {
    public void save(Employee employee){
        // 打开资源
        // 开启事务
        try {
            // 保存业务操作
            // 提交事务
        }catch (Exception e){
            // 回滚事务
        }finally{
            // 释放资源
        }
    }
}

上述问题：在我们的业务层中每一个业务方法都得处理事务（繁琐的 try-catch），这样设计上存在两个很严重问题：

  • 代码结构重复：在开发中不要重复代码，重复就意味着维护成本增大；
  • 责任不分离：业务方法只需要关心如何完成该业务功能，不需要去关系事务管理、日志管理、权限管理等等。

2、租房案例

在这里插入图片描述

问题：此时若有人来整房东，派很多人来找房东假租房，这会导致房东一天到晚都忙且没收获。带来这个问题就是：重复，且责任不分离，其实房东最关系的就是签合同和收房租。

在这里插入图片描述

后面我们就借鉴上面生活的例子的思想来之前事务繁琐的问题。

七、代理模式（了解）

1、好处

客户端直接使用的都是代理对象，不知道真实对象是谁，此时代理对象可以在客户端和真实对象之间起到中介的作用。

  • 代理对象完全包含真实对象，客户端使用的都是代理对象的方法，和真实对象没有直接关系；
  • 代理模式的职责：把不是真实对象该做的事情从真实对象上撇开—职责分离。

2、分类

  • 静态代理：在程序运行前就已经存在代理类的字节码文件，代理对象和真实对象的关系在运行前就确定了。（即代理类及对象要我们自己创建）
  • 动态代理：代理类是在程序运行期间由 JVM 通过反射等机制动态的生成的，所以不存在代理类的字节码文件，动态生成字节码对象，代理对象和真实对象的关系是在程序运行时期才确定的。（即代理类及对象不要我们自己创建）

3、动态代理实现方式

  • 针对真实类有接口使用 JDK 动态代理；
  • 针对真实类没实现接口使用 CGLIB 或 Javassist 组件。

4、动态代理实现机制

由于 JVM 通过字节码的二进制信息加载类的，若我们在运行期系统中，遵循 Java 编译系统组织 .class 文件的格式和结构，生成相应的二进制数据，然后再把这个二进制数据加载转换成对应的类。如此，就完成了在代码中动态创建一个类的能力了。

在这里插入图片描述

八、静态代理（了解）

1、需求

给业务类的方法增加模拟的事务。

2、类体系图

在这里插入图片描述

3、代码实现

新建一个 Maven 项目 static-proxy。

3.1、设置编译版本及添加依赖

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
</properties>

<dependencies>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
		<version>5.0.8.RELEASE</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-test</artifactId>
		<version>5.0.8.RELEASE</version>
		<scope>test</scope>
	</dependency>
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.12</version>
		<scope>test</scope>
	</dependency>
</dependencies>

3.2、编写业务接口及实现

package cn.wolfcode.service;

public interface IEmployeeService {
	void save(String username, String password);
}

package cn.wolfcode.service.impl;

// 房东
// 真实类，其对象为真实对象
public class EmployeeServiceImpl implements IEmployeeService {
	@Override
	public void save(String username, String password) {
		System.out.println("保存：" + username + ":" + password);
	}
}

3.3、编写代理类

package cn.wolfcode.service.impl;

// 中介
// 代理类，其对象为代理对象
public class EmployeeServiceProxy implements IEmployeeService {

	// 房东引用，真实对象引用
	private IEmployeeService target;
	public void setTarget(IEmployeeService target) {
		this.target = target;
	}
	
	private MyTransactionManager tx;
	public void setTx(MyTransactionManager tx) {
		this.tx = tx;
	}
	
	@Override
	public void save(String username, String password) {
		try {
			tx.begin();
			// 保存的业务操作,找房东来做，找真实对象来做
			target.save(username, password);
			tx.commit();
		}catch (Exception e) {
			e.printStackTrace();
			tx.rollback();
		}
	}
}

3.4、编写事务模拟类

package cn.wolfcode.tx;

public class MyTransactionManager {
	public void begin() {
		System.out.println("开启事务");
	}
	public void commit() {
		System.out.println("提交事务");
	}
	public void rollback() {
		System.out.println("回滚事务");
	}
}

3.5、编写 applicationContext.xml

在 resources 目录新建 applicationContext.xml，配置如下：

<!-- 配置事务管理器对象 -->
<bean id="tx" class="cn.wolfcode.tx.MyTransactionManager"/>
	
<!-- 配置代理对象 -->
<bean id="employeeServiceProxy" class="cn.wolfcode.service.impl.EmployeeServiceProxy">
    <property name="target">
        <!-- 配置真实对象, 藏起来 -->
        <bean class="cn.wolfcode.service.impl.EmployeeServiceImpl"/>
    </property>
    <property name="tx" ref="tx"></property>
</bean>

3.6、编写单元测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class EmployeeServiceTest { 
    @Autowired
    private IEmployeeService proxy;
    
    @Test
    public void testSave() {
        // proxy 为代理对象
        proxy.save("罗老师", "666");
    }
}

4、优缺点

4.1、优点

  • 业务类只需要关注业务逻辑本身，保证了业务类的重用性。
  • 把真实对象隐藏起来了，保护真实对象。

4.2、缺点

  • 代理对象的某个接口只服务于某一种类型的对象，也就是为每个真实类创建一个代理类，比如项目还有其他业务类呢。
  • 若需要代理的方法很多，则要为每一种方法都进行代理处理。
  • 若接口增加一个方法，除了所有实现类需要实现这个方法外，代理类也需要实现此方法。

九、JDK 动态代理（了解）

1、需求

给业务类的方法增加模拟的事务。

2、JDK 动态代理 API

2.1、java.lang.reflect.Proxy

Java 动态代理机制生成的所有动态代理类的父类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。主要方法：public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler hanlder)

  • 方法职责：为指定类加载器、一组接口及调用处理器生成动态代理类实例。
  • 参数：
    • loader ：类加载器，一般传递真实对象的类加载器；
    • interfaces：代理类需要实现的接口；
    • handler：代理执行处理器，说人话就是生成代理对象帮你要做什么。
  • 返回：创建的代理对象。

2.2、java.lang.reflect.InvocationHandler

主要方法：public Object invoke(Object proxy, Method method, Object[] args)。

  • 方法职责：负责集中处理动态代理类上的所有方法调用，让使用者自定义做什么事情， 对原来方法增强（加什么功能）。
  • 参数：
    • proxy ：生成的代理对象；
    • method：当前调用的真实方法对象；
    • args ：当前调用方法的实参。
  • 返回：真实方法的返回结果。

3、代码实现

3.1、拷贝静态代理项目

  • 修改项目名为 jdk-dynamic-proxy，重新导入；
  • 删除自己手写的代理类，配置文件报错顺便解决。

3.2、编写 TransactionInvocationHandler 类

该实现 InvocationHandler 接口，实现 invoke 方法，实现增强操作。

package cn.wolfcode.handler;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import cn.wolfcode.tx.MyTransactionManager;

public class TransactionInvocationHandler implements InvocationHandler {

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

	private MyTransactionManager tx;
	public void setTx(MyTransactionManager tx) {
		this.tx = tx;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("到此一游");
		Object retVal = null;
		try {
			tx.begin(); // 调用事务管理器对象的方法
			retVal= method.invoke(target, args); // 调用真实对象的方法
			tx.commit(); // 调用事务管理器对象的方法
		}catch (Exception e) {
			tx.rollback(); // 调用事务管理器对象的方法
		}
		return retVal; // 返回方法调用的结果
	}
}

3.3、修改 applicationContext.xml

配置 TransactionInvocationHandler、MyTransactionManager、EmployeeServiceImpl，让 Spring 帮我们创建这些对象组装依赖。

<!-- 配置事务管理器对象 -->
<bean id="tx" class="cn.wolfcode.tx.MyTransactionManager"/>

<!-- 配置处理器执行器对象 -->
<bean id="transactionInvocationHandler" class="cn.wolfcode.handler.TransactionInvocationHandler">
    <property name="target">
        <bean class="cn.wolfcode.service.impl.EmployeeServiceImpl"/>
    </property>
    <property name="tx" ref="tx"/>
</bean>

3.4、修改单元测试类

注入类型 InvocationHandler 的 bean，在测试方法中手动使用 Proxy 中的方法创建代理对象，调用代理对象的方法。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class EmployeeServiceTest {
    @Autowired
    private TransactionInvocationHandler transactionInvocationHandler;
    
    @Test
    public void testSave() {
        // 动态生成代理类，并创建代理对象
        IEmployeeService proxy = (IEmployeeService)Proxy.newProxyInstance(
            transactionInvocationHandler.getTarget().getClass().getClassLoader(),
            // 获取真实类实现的接口，生成的代理类也是实现什么的接口
            transactionInvocationHandler.getTarget().getClass().getInterfaces(),
            // 通过这个参数告诉 API 生成代理对象具体做什么
            transactionInvocationHandler);
        proxy.save("罗老师", "666");
    }

}

4、优缺点

4.1、优点

  • 对比静态代理，发现不需手动地提供那么多代理类。

4.2、缺点

  • 真实对象必需实现接口（JDK 动态代理特有）；
  • 动态代理的最小单位是类（类中某些方法都会被处理），如果只想拦截一部分方法，可以在 invoke 方法中对要执行的方法名进行判断；
  • 对多个真实对象进行代理的话，若使用 Spring 的话配置太多了，要手动创建代理对象，用起来麻烦。

十、JDK 动态代理原理（了解）

1、获取代理类字节码文件

ProxyGenerator 在 JDK 11 已经不是公有的了。

在包路径 cn.wolfcode.service.impl 下新建一个类 DynamicProxyClassGenerator，拷贝如下代码：

public class DynamicProxyClassGenerator {
	public static void main(String[] args) throws Exception {
		generateClassFile(EmployeeServiceImpl.class, "EmployeeServiceProxy");
	}
	public static void generateClassFile(Class<?> targetClass, String proxyName) throws Exception {
		// 根据类信息和提供的代理类名称，生成字节码
		byte[] classFile = ProxyGenerator.generateProxyClass(proxyName, targetClass.getInterfaces());
		String path = targetClass.getResource(".").getPath();
		System.out.println(path);
		FileOutputStream out = null;
		// 保留到硬盘中
		out = new FileOutputStream(path + proxyName + ".class");
		out.write(classFile);
		out.close();
	}
}

2、通过反编译工具查看字节码文件

使用 IDEA 就可以反编译。观察：save 方法，发现底层其实依然在执行 InvocationHandler 中的 invoke 方法。

3、类体系及调用流程

在这里插入图片描述

十一、CGLIB 动态代理（了解）

1、JDK 动态代理的问题

JDK 动态代理要求真实类必须实现接口。而 CGLIB 与 JDK 动态代理不同是，真实类不用实现接口，生成代理类的代码不一样且代理类会继承真实类。

2、CGLIB 动态代理 API

2.1、org.springframework.cglib.proxy.Enhancer

类似 JDK 中 Proxy，用来生成代理类创建代理对象的。

2.2、org.springframework.cglib.proxy.InvocationHandler

类似 JDK 中 InvocationHandler，让使用者自定义做什么事情，对原来方法增强。

3、代码实现

3.1、拷贝 JDK 动态代理项目

修改项目名为 jdk-cglib-proxy，重新导入。

3.2、修改 TransactionInvocationHandler 类

修改其实现接口为 org.springframework.cglib.proxy.InvocationHandler，其他不变。

3.3、修改单元测试类

改用 Enhancer API 来生成代理类创建代理对象。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class EmployeeServiceTest {
	
	@Autowired
	private TransactionInvocationHandler transactionInvocationHandler;
	
	@Test
	public void testSave() {
		Enhancer enhancer = new Enhancer();
		// 设置生成代理类继承的类
		enhancer.setSuperclass(transactionInvocationHandler.getTarget().getClass());
		// 设置生成代理类对象对象，要做什么事情
		enhancer.setCallback(transactionInvocationHandler);
		// 生成代理类，创建代理对象
		EmployeeServiceImpl proxy = (EmployeeServiceImpl)enhancer.create();
		proxy.save("罗老师", "666");
	}

}

4、类体系及调用流程

在这里插入图片描述

十二、动态代理总结（了解）

1、JDK 动态代理总结

  • Java 动态代理是使用 java.lang.reflect 包中的 Proxy 类与 InvocationHandler 接口这两个来完成的。
  • 要使用 JDK 动态代理，真实类必须实现接口。
  • JDK 动态代理将会拦截所有 pubic 的方法（因为只能调用接口中定义的方法），这样即使在接口中增加了新的方法，不用修改代码也会被拦截。
  • 动态代理的最小单位是类（类中某些方法都会被处理），如果只想拦截一部分方法，可以在 invoke 方法中对要执行的方法名进行判断。
  • 代理类与真实类共同实现相同接口的。

2、CGLIB 动态代理总结

  • CGLIB 可以生成真实类的子类，并重写父类非 final 修饰符的方法。
  • 要求类不能是 final 的，要拦截的方法要是非 final、非 static、非 private 的。
  • 动态代理的最小单位是类（类中某些方法都会被处理），如果只想拦截一部分方法，可以在 invoke 方法中对要执行的方法名进行判断。
  • 代理类是继承真实类。

3、选用

JDK 动态代理是基于实现接口的，CGLIB 和 Javassit 是基于继承真实类的。

从性能上考虑：Javassit > CGLIB > JDK。

选用如下：

  • 若真实类实现了接口，优先选用 JDK 动态代理。（因为会产生更加松耦合的系统，也更符合面向接口编程）
  • 若真实类没有实现任何接口，使用 Javassit 和 CGLIB 动态代理。

上一篇: Spring (一) 之 IoC和DI；

下一篇: Spring (三) 之Aop及事务控制；

北执南念
关注
  • 9
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringAOP之探秘（动态代理、责任链模式、注解使用）
12-14
SpringAOP之探秘（动态代理、责任链模式、注解使用）- 详情：https://blog.csdn.net/Dream_Weave/article/details/85008674
Spring高级之注解驱动开发视频教程
11-05
n 设计模式-代理模式 n 编程思想-AOP思想 n 基础应用-入门案例 n 基础应用-常用注解 n 高级应用-DeclareParents注解 n 高级应用-EnableLoadTimeWeaving n 源码分析-@EnableAspectJAutoproxy注解加载过程分析 n 源码...
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
06-21
Java 动态代理是 Java 编程语言中的一种强大工具，广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解对象获取、日志、用户鉴权、全局性异常处理、性能监控等领域。...
Spring AOP源码深度解析：掌握Java高级编程核心技术
12-13
Spring AOP是基于代理模式实现的，主要包括动态代理、通知（Advice）、切点（Pointcut）、切面（Aspect）和连接点（Join point）。动态代理是实现AOP的基础，它通过JDK动态代理或CGLIB代理生成被代理对象的子类。...
spring.doc
10-25
代理模式拓展： 52 4.1.1 JDK动态代理 58 JDK动态代理拓展： 59 4.1.2 CGLIB做代理 66 CGLIB动态代理拓展： 68 4.1.3 Spring的动态代理 71 4.2 AOP编程 71 4.2.1概念： 71 SpringAOP概念拓展： 73 之前实现了目标...
6、Spring之Bean生命周期~创建Bean（2）
sproutBoy的博客
06-10 678
【代码】6、Spring之Bean生命周期~创建Bean（2）
springboot与flowable（2）：流程部署
游王子的博客
06-10 283
选择建模器应用程序选择要导出的建模点击导出按钮。将导出的文件复制到项目中。
SpringCloud之Zuul源码解析
qq_36851469的博客
06-10 234
Zuul 是在云平台上提供动态路由，监控，弹性，安全等边缘服务的框架。Zuul 相当于是设备和 Netflix 流应用的 Web 网站后端所有请求的前门。Zuul 可以适当的对多个 Amazon Auto Scaling Groups 进行路由请求。其架构如下图所示：Zuul提供了一个框架，可以对过滤器进行动态的加载，编译，运行。过滤器之间没有直接的相互通信。他们是通过一个RequestContext的静态类来进行数据传递的。
SpringBoot之请求映射原理
好记性不如烂笔头
06-12 1107
我们发出的请求，SpringMVC是如何精准定位到那个Controller以及具体方法？其实这都是 HandlerMapping 发挥的作用，这篇博文我们以 RequestMappingHandlerMapping 为例并结合源码一步步进行分析。默认 HandlerMapping 主要定义在和其祖父类中获取所有类型是 Object 的 beans，并且 beanName 不以开头根据 beanName 获取 beanType如果 beanType 上存在注解则进行处理。
JAVA学习笔记DAY5——SSM_Spring
最新发布
weixin_47227105的博客
06-13 391
Spring Ioc容器是复杂容器。一个项目project拆分成多个模块module。配置方式包括三种：xml、注解、配置类。从文件结构的角度看，框架=jar包+是SSM的一种简化，快速创建服务。用来维护不同服务的相互调用。控制层组件 Servlet。业务逻辑层 Service。持久化层组件 Dao。
SpringBoot项目启动提示端口号占用
点滴汇聚，智在积累。——Danny
06-07 230
通过netstat查看当前端口号并没有被占用啊，那可能是使用了系统保留端口，通过。1、换个端口（不在系统保留端口的范围）于是换个端口号试试，还是提示占用。2、关闭hyper-v。
springboot连接多个库
sunyingboaini的博客
06-11 169
一个SpringBoot项目，同时连接两个数据库：比如一个是Mysql数据库，一个是oracle数据库（啥数据库都一样，连接两个同为oracle的数据库，或两个不同的数据库，只需要更改对应的driver-class-name和jdbc-url等即可）注意：连接什么数据库，要引入对应数据库的包。
springBoot多数据源使用、配置
qx020814的博客
06-12 275
又参加了一个新的项目，虽然是去年做的项目，拿来复用改造，但是也学到了很多。这个项目会用到其他项目的数据，如果调用他们的接口取数据，我还是觉得太麻烦了。打算直接配置多数据源。使用@DS("数据源名称") ，就能指定使用某一个数据源。就是配置两个数据库信息，后续使用@DS("数据源名称")配置了druid之后，项目运行起来就能访问,然后去另一个数据库系统中取出数据。,可以看见有两个数据源可以使用。所以就去了解和学习了一下。
SpringBootWeb 篇-深入了解 AOP 面向切面编程与 AOP 记录操作日志案例
小扳手
06-07 1646
AOP，Aspect Oriented Programming 面向切面编程，在 AOP 中，横切关注点被称为切面（Aspect），切面通过特定的注入方式被应用到程序的不同部分，从而实现对这些部分的增强或修改。AOP 能够帮助开发者更好地管理程序的复杂性，提高代码的重用性和易读性。简单来说，就是面向特定的方法编程，也或者说给原始的方法进行升级改造。这样原始的方法就不需要进行改变，从而实现方法升级了。如日志记录、权限控制等功能。通过AOP，可以实现方法的升级改造，提高代码的可维护性和可重用性。
【源码】Spring Data JPA原理解析之事务执行原理
JingAi_jia917的博客
06-07 1407
本篇从源码的角度分析了Spring Data JPA事务Transaction的处理过程。重点分析了TransactionAspectSupport、AbstractPlatformTransactionManager、JpaTransactionManager的源码。
深入理解Spring相关注解
Java领域优秀创作者
06-13 515
Spring框架是Java开发中最受欢迎的框架之一，其提供了大量的注解来简化开发流程，提高代码的可读性和可维护性。本文将详细介绍Spring中常用的注解，包括核心容器、Web开发、数据访问等方面的注解，旨在帮助读者深入理解Spring框架的注解机制。
SpringMVC
weixin_44553952的博客
06-11 1248
过滤器的设计初衷是为了处理 Servlet 请求和响应，它们并不属于 Spring 容器的管理范围，因此在过滤器中无法直接通过 Spring 上下文来访问 Spring 托管的 Bean。控制器：一个或多个 Servlet 对象，根据视图提交的请求进行控制，即将请求转发给处理业务逻辑的 JavaBean，并将处理结果存放到实体模型 JavaBean 中，输出给视图显示。图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。
【java计算机毕设】图书管理系统javaweb java MySQL springboot vue html maven送文档+ppt 代码源码计算机项目
qq_41768325的博客
06-11 1040
系统功能： 智慧图书管理系统包括管理员和用户两种角色。 管理员的功能包括在个人中心修改个人信息和密码，管理员功能模块管理管理员。基础数据管理模块包含图书出版管理、公告类型、所在书架管理、图书类型管理。论坛管理功能模块管理论坛。公告信息管理模块管理公告信息管理。图书信息管理模块管理图书信息管理。借阅信息管理模块管理借阅信息。用户管理模块管理用户。轮播图信息管理模块管理轮播图 用户的功能包括在个人中心修改个人信息和密码，论坛管理模块允许用户浏览帖子和查看留言，公告信息管理模块浏览公告信息、图书信息管理模块浏览图
Spring Data JPA 通过方法名查询，通过名字查找用户区分用户名大小写吗
qq_30517167的博客
06-12 139
总结来说，Spring Data JPA 的方法名查询是否区分大小写主要取决于数据库的校对集设置。其次，真正决定查询是否区分大小写的是数据库中的列所使用的校对集（collation）。Spring Data JPA 通过方法名来定义查询时，是否区分大小写主要取决于底层数据库的校对集（collation）和JPA查询的默认行为。但是，你可以通过JPQL或Criteria查询来明确指定查询的大小写敏感性。校对集，那么通过Spring Data JPA的方法名查询时，默认情况下是不区分大小写的。
spring 事务注解失效的原因
05-19
Spring 事务的实现依赖于代理机制，如果没有使用代理模式，那么事务注解也会失效。可以使用基于接口的代理或基于类的代理两种方式来开启代理模式。 3. 方法访问权限问题。如果方法的访问权限为 `private`，那么 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值