尚硅谷Spring框架学习笔记（中）

最新推荐文章于 2024-08-15 17:22:10 发布
最新推荐文章于 2024-08-15 17:22:10 发布
阅读量375 收藏 4
点赞数 4
分类专栏： SSM 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45685031/article/details/120705039
版权

文章目录


本文是在看了b站的 尚硅谷Spring5框架教程（idea版）
总结出来的笔记以及见解
尚硅谷Spring框架学习笔记（上）：

AOP（概念）

1.什么是AOP

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

（2）通俗描述就是：不通过修改源代码的方式添加新功能

（3）使用登录的例子来说明AOP
imgs

AOP（底层原理）

1.AOP底层使用动态代理

（1）有两种情况的动态代理

第一种情况：有接口，使用JDK动态代理（动态代理spring5已经进行了封装）

*创建借口实现类代理对象，增强类的方法
imgs

第二种情况：没有接口，使用CGLIB动态代理

*创建子类的代理对象，增强类的方法
imgs

AOP（JDK动态代理）

1.使用JDK动态代理，使用Proxy类里面的方法创建代理对象
imgs
（1）调用newProxyInstance方法
在这里插入图片描述

方法有三个参数：

第一个参数：是类加载器

第二个参数：增强方法所在的类，这个类实现的接口，支持多个接口

第三个参数，实现里面的接口InvocationHandler，创建代理对象，写增强的方法

2.JDK动态代理代码编写

（1）创建接口，定义方法

public interface UserDao {

    public 	int add(int a,int b) ;

    public void update(String id);
}

（2）创建接口的实现类，实现方法

public class UserDaoImpl implements UserDao {

	@Override
	public int add(int a, int b) {
		// TODO Auto-generated method stub
		System.out.println("add方法被执行了....");
		return a+b;
	}

	@Override
	public String  update(String id) {
		// TODO Auto-generated method stub
		System.out.println("update被执行了.....");
		return id;
	}
}

（3）使用Proxy类创建接口代理对象


public class JDKProxy {

	public static void main(String[] args) {
		// 创建接口实现的代理对象
		Class[] interfaces = { UserDao.class };
		//匿名内部类
//		Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {			
//			@Override
//			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//				// TODO Auto-generated method stub
//				return null;
//			}
//		});
		UserDaoImpl userDao = new UserDaoImpl();
		UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces,
				new UserDaoProxy(userDao));
		System.out.println("--------------------------");
		int result = dao.add(1, 2);
		System.out.println("result:" + result);
	}
}

//创建代理对象代码
class UserDaoProxy implements InvocationHandler {

	// 1.把创建的是谁的代理对象，把谁传递过来
	// 有参数结构传递
	private Object obj;

	public UserDaoProxy(Object obj) {
		// TODO Auto-generated constructor stub
		this.obj = obj;
	}

	// 增强的逻辑
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// proxy：代理对象 method：当前方法    args：参数
		// method.getName()表示执行的哪一个方法
		// 在方法之前
		System.out.println("方法执行之前....." + method.getName() + ":传递的参数" + Arrays.toString(args));

		// 被增强的方法执行
		Object res = method.invoke(obj, args);
		
		// 在方法之后
		System.out.println("方法执行之后...." + obj);
		return res;
	}
}

AOP（术语）

1.连接点
imgs
2.切入点
在这里插入图片描述

3.通知（增强）
在这里插入图片描述

4.切面
在这里插入图片描述

AOP操作（准备）

1.spring框架一般都是基于AspectJ实现AOP操作

（1）什么是AspectJ

*AspectJ不是Spring组成的部分，独立AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作

2.基于AspectJ实现AOP操作

（1）基于xml配置文件实现

（2）基于注解方式实现（使用）

3.在项目工程里面引入AOP相关依赖

在这里插入图片描述

4.切入点表达式

（1）切入表达式作用：知道哪个类里面的那个方法进行增强

（2）语法结构

execution([权限修饰符] [返回类型] [类全路径] [方法名称] ([参数列表]))

举例1：对com.atguigu.dao.BookDao；类里面的add进行增强

execution(*com.atguigu.dao.BookDao.add(…))

举例2：对com.atguigu.dao.BookDao类里面所有方法进行增强

execution(*com.atguigu.dao.BookDao. *(…))

举例3：：对com.atguigu.dao包里面所有方法进行增强

execution(*com.atguigu.dao. *. *(…))

AOP操作（AspectJ注解）

1.创建类，在类里面定义方法

public class User {

	public void add() {
		System.out.println("add........");
	}
}

2.创建增强类（编写增强逻辑）

(1)在增强类里面,创建方法，让不同方法代表不同通知类型

//增强的类
public class UserProxy {
	//前置通知
	public void before() {
		System.out.println("before.......");
	}
}

3.进行通知配置

（1）在spring配置文件中，开启注解扫描

<?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:aop="http://www.springframework.org/schema/aop"
	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/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
	<!-- 开启组件扫描 -->
	<context:component-scan
		base-package="pdsu.edu.aopanno"></context:component-scan>

</beans>

（2）使用注解创建User和UserProxy对象

//被增强的类
@Component
public class User {

	public void add() {
		System.out.println("add........");
	}
}

//增强的类
@Component
public class UserProxy {

	//前置通知
	public void before() {
		System.out.println("before.......");
	}
}

（3）在增强类上面添加注解@Aspect

//增强的类
@Component
@Aspect//生成代理对象
public class UserProxy {

	//前置通知
	public void before() {
		System.out.println("before.......");
	}
}

（4）在spring配置文件中开启生成代理对象

<!-- 开启Aspect生成代理对象 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

4.配置不同类型的通知

（1）在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

//增强的类
@Component
@Aspect//生成代理对象
public class UserProxy {

	//注解表示前置通知
	//@Before注解表示作为前置通知
	@Before(value="execution(* pdsu.edu.aopanno.User.add(..))")
	public void before() {
		System.out.println("before.......");
	}
	@After(value="execution(* pdsu.edu.aopanno.User.add(..))")
	public void after() {
		System.out.println("After........");
	}
	
	@AfterReturning(value="execution(* pdsu.edu.aopanno.User.add(..))")
	public void afterReturning() {
		System.out.println("afterReturning........");
	}
	
	//异常通知
	@AfterThrowing(value="execution(* pdsu.edu.aopanno.User.add(..))")
	public void afterThrowing() {
		System.out.println("afterThrowing........");
	}
	@Around(value="execution(* pdsu.edu.aopanno.User.add(..))")
	public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
		System.out.println("环绕之前........");
		
		//被增强的方法执行
		proceedingJoinPoint.proceed();
		
		System.out.println("环绕之后........");
	}
}

测试

public class test1 {

	public static void main(String[] args) {
		
		ApplicationContext con =new ClassPathXmlApplicationContext("bean1.xml");
	User user = con.getBean("user",User.class);
	user.add();
	}
}

运行结果：

环绕之前…
before…
add…
afterReturning…
After…
环绕之后…

*@After，@AfterReturning都是程序执行后执行

区别：@After方法之后执行，一定执行

​ @AfterReturning返回值（后置通知）之后执行，有异常不通知

@AfterThrowing//异常通知（没有异常不通知）

5.相同切入点抽取,修改方便

//相同切入点抽取
	@Pointcut(value="execution(* pdsu.edu.aopanno.User.add(..))")
	public void pointdemo() {
		
	}
		
	//@Before注解表示作为前置通知
	@Before(value="pointdemo()")
	public void before() {
		System.out.println("before.......");
	}

6.有多个增强类执行同一个方法，设置增强类优先级

（1）在增强类的上面添加注释@Order（数字类型），数字值越小优先级越高，最小为0（控制台最后打印结果）

@Component
@Aspect
@Order(0)
public class PersonProxy {

	@AfterReturning(value="execution(* pdsu.edu.aopanno.User.add(..))")
	public void afterReturning() {
		System.out.println("PersonProxy   afterReturning........");
	}
	
}

7.完全使用注解开发

(1)创建配置类，不需要xml文件

@CacheConfig
@ComponentScan(basePackages = "pdsu.edu.aopxml")
@EnableAspectJAutoProxy(proxyTargetClass = true)//默认false
public class ConfigAop {

}

AOP操作(ASpectJ配置文件，了解)

1.创建两个类，增强类和被增强类，创建方法

2.在spring配置文件中创建两个类对象

3.在spring配置文件中配置切入点

<?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:aop="http://www.springframework.org/schema/aop"
	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/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
	<!-- 创建对象 -->
	<bean id="book" class="pdsu.edu.aopxml.Book"></bean>
	<bean id="bookProxy" class="pdsu.edu.aopxml.BookProxy"></bean>

	<!-- 配置aop增强 -->
	<aop:config>
		<!-- 切入点 -->
		<aop:pointcut
			expression="execution(* pdsu.edu.aopxml.Book.buy(..))" id="p" />
		<!-- 配置切面 -->
		<aop:aspect ref="bookProxy">
			<!-- 增强作用具体到方法上 -->
			<aop:before method="before" pointcut-ref="p" />
		</aop:aspect>
	</aop:config>
</beans>

JdbcTemplate(概念和准备)

1.什么是JdbcTemplate

（1）Spring框架对JDBC进行封装，使用JdbcTemplate方便实现

2.准备工作

（1）引入相应的jar包
在这里插入图片描述

（2）在spring配置文件配置数据库连接池

<!-- 先引入外部属性文件 -->
	<context:property-placeholder  location="classpath :jdbc.properties"/>
	<!-- 数据库连接池 -->
	<bean id="dataSource"
		class="com.alibaba.druid.pool.DruidDataSource">
		<property name="driverClassName"
			value="${prop.driverClassName}"></property>
		<property name="url" value="${prop.url}"></property>
		<property name="username" value="${prop.username}"></property>
		<property name="password" value="${prop.password}"></property>
	</bean>

jdbc.properties文件

prop.driverClassName=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/text
prop.username=root
prop.password=123456

（3）配置JdbcTemplate对象，注入DataSource

<!-- JdbcRemplate对象 -->
	<bean id="jdbcTemplate" class="org.spring framework.jdbc.core.JdbcTemplate">
	<!-- 注入DataSource -->
	<property name="dataSource" ref="dataSource"></property>	
	</bean>

（4）创建service 类，创建dao类，在dao注入JdbcTemplate对象

*配置文件

<!-- 开启注解扫描 -->
	<context:component-scan base-package="pdsu.edu"></context:component-scan>
        <!-- JdbcTemplate对象 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	<!-- 注入DataSource -->
	<property name="dataSource" ref="dataSource"></property>	
	</bean>

Service类

@Service
public class BookService {
	//注入dao
	@Autowired//根据类型进行注入
	private BookDao bookDao;

	//添加方法
	public void addBook(Book book) {
		bookDao.add(book);
	}
}

Dao类

@Repository
public class BookDaoImpl implements BookDao{

	
	//注入JdbcTemplate
	@Autowired
	private JdbcTemplate jdbcJdbcTemplate;
}

JdbcTemplate操作数据(添加)

1.对应数据库创建实体类

public class User {

	private String userId;
	private String username;
	private String ustatus;
	public void setUserId(String userId) {
		this.userId = userId;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public void setUstatus(String ustatus) {
		this.ustatus = ustatus;
	}
	public String getUserId() {
		return userId;
	}
	public String getUsername() {
		return username;
	}
	public String getUstatus() {
		return ustatus;
	}
	
}

2.编写service和dao

（1）在dao进行进行数据库添加操作

（2）调用JdbcTemplate对象里面update方法实现添加操作

update(String sql，Object…args)

*有两个参数

第一个参数：是sql语句

第二个参数：可变参数，设置sql语句

@Repository
public class BookDaoImpl implements BookDao{

	
	//注入JdbcTemplate
	@Autowired
	private JdbcTemplate jdbcTemplate;

	//添加的方法
	@Override
	public void add(Book book) {
		String sql="insert into t_book values(?,?,?)";
		//2.调用方法实现
		Object[] args= {book.getUserId(),book.getUsername(),book.getUstatus()};
	    int data  =jdbcTemplate.update(sql,args);
		System.out.println(data);
	}
}

3.测试类

public class test {

	public static void main(String[] args) {
		 ApplicationContext con =
				 new ClassPathXmlApplicationContext("bean1.xml");
		 BookService bookService = con.getBean("bookService",BookService.class);
	    Book book1 = new Book("1","java","a");
	    Book book2 = new Book("2","ph","b");
		 bookService.addBook(book1);
		 bookService.addBook(book2);
	}
}

在这里插入图片描述

jdbcTemplate操作数据库（修改和删除)

修改操作：

//修改图书的方法
	@Override
	public void updateBook(Book book) {
		Object[] args= {book.getUsername(),book.getUstatus(),book.getUserId()};
		String sql="update t_book set username=?,ustatus=? where user_id=?";
		int update = jdbcTemplate.update(sql, args);
		System.out.println(update);
	}

删除操作:

//删除图书的方法
	@Override
	public void deleteBook(String id) {
		String sql = "delete from t_book where user_id=?";
		int update = jdbcTemplate.update(sql, id);
		System.out.println(update);
		
		
	}

测试：

		 //修改操作
//		    Book book1 = new Book("1","Java","aa");
//		    Book book2 = new Book("2","PH","bb");
//			 bookService.updateBook(book1);
//			 bookService.updateBook(book2);
		 
		 //删除操作
		 bookService.deleteBook("2");

jdbcTemplate操作数据库(查询返回某个值)

1.查询表里面有多少记录，返回某个值

2.使用JdbcTemplate
imgs

有两个参数

*第一个参数：sql语句

*第二个参数：返回类型的class

//查询表记录数
	@Override
	public int selectCount() {
		String sql = "select count(*) from t_book";
		Integer count = jdbcTemplate.queryForObject(sql, Integer.class);		
		return count;
		
	}

jdbcTemplate操作数据库(查询返回对象)

1.场景：查询图书详情

2.JdbcTemplate实现查询返回对象
imgs

有三个参数

*第一个参数：sql语句

*第二个参数：RowMapper，是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装

*第三个参数：sql语句值

	//查询返回对象
	@Override
	public Book findBookInfo(String id) {
		String sql ="select * from t_book where user_id=?";
		//调用方法
		Book book=  (Book) jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class),id);
		return book;
	}

jdbcTemplate操作数据库(查询返回集合)

1.场景：查询图书列表分页…

2.调用JdbcTemplate方法实现返回集合
imgs

有三个参数

*第一个参数：sql语句

*第二个参数：RowMapper，是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装

*第三个参数：sql语句值（可以没有）

//返回集合类型
	@Override
	public List<Book> findAllBook() {
		// TODO Auto-generated method stub
		String sql = "select * from t_book";
		List<Book> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
		return list;
	}

JdbcTemplate操作数据库（批量添加操作）

1.批量操作：操作表里面多条记录

2.JdbcTemplate实现批量添加操作
imgs

有两个参数

*第一个参数：sql语句

*第二个参数：List集合，添加多条记录数据

//批量添加
	@Override
	public void batchAddBook(List<Object[]> batchArgs) {
		String sql="insert into t_book values(?,?,?)";
		int[] ints = jdbcTemplate.batchUpdate(sql,batchArgs);
		System.out.println(Arrays.toString(ints));
	}

测试:

 //批量添加
		 List<Object[]> batchArgs =new ArrayList<>();
		 Object[] o1 = {"3","javac","a"};
		 Object[] o2 = {"4","c++","b"};
		 Object[] o3 = {"5","MySQL","c"};
		 batchArgs.add(o1);
		 batchArgs.add(o2);
		 batchArgs.add(o3);
		 //调用批量添加
		 bookService.batchAdd(batchArgs);

JdbcTemplate操作数据库（批量修改操作）

//批量修改
	@Override
	public void batchUpdateBook(List<Object[]> batchArgs) {
		String sql="update t_book set username=?,ustatus=? where user_id=?";
		int[] ints = jdbcTemplate.batchUpdate(sql,batchArgs);
		System.out.println(Arrays.toString(ints));
	}

	//批量删除
	@Override
	public void batchDeleteBook(List<Object[]> batchArgs) {
		String sql = "delete from t_book where user_id=?";
		int[] ints = jdbcTemplate.batchUpdate(sql,batchArgs);
		System.out.println(Arrays.toString(ints));
		
	}

测试：

		 //批量修改
//		 List<Object[]> batchArgs =new ArrayList<>();
//		 Object[] o1 = {"javac","aa","3"};
//		 Object[] o2 = {"c++","bb","4"};
//		 Object[] o3 = {"MySQL","cc","5"};
//		 batchArgs.add(o1);
//		 batchArgs.add(o2);
//		 batchArgs.add(o3);
//		//调用批量修改
//		 bookService.batchUpdate(batchArgs);
		 
		 //批量删除
//		 List<Object[]> batchArgs =new ArrayList<>();
//		 Object[] o2 = {"4"};
//		 Object[] o3 = {"5"};
//		 batchArgs.add(o2);
//		 batchArgs.add(o3);
//		 bookService.batchDelete(batchArgs);

后续笔记会持续更新，希望大家给个一键三连！！！！！
imgs

Mylife0506
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
尚硅谷SpringMVC部分全套教学文档笔记
07-04
尚硅谷SpringMVC教学文档笔记，完整全面的SpringMVC知识要点总结及笔记
尚硅谷最新视频全套，包含springboot，SpringCloud等
05-01
最新的尚硅谷视频，包括springcloud和linux，通用mapper等。都在百度云链接中
尚硅谷Spring学习笔记（1）-- Spring基础知识
热门推荐
exodus3的博客
04-14 1万+
一、课程内容介绍 1、Spring 框架概述 2、IOC 容器 （1）IOC 底层原理 （2）IOC 接口（BeanFactory） （3）IOC 操作 Bean 管理（基于 xml） （4）IOC 操作 Bean 管理（基于注解） 3、Aop 4、JdbcTemplate 5、事务管理 6、Spring5 新特性 二、Spring5 框架概述 1、Spring 是轻量级的开源的 JavaEE 框架 2、Spring 可以解决企业应用开发的复杂性 3、Spring 有两个核心部分：IOC 和 Aop （1）
【尚硅谷学习笔记】spring security 入门一
m0_60707623的博客
10-18 155
尚硅谷 spring security 笔记
学习笔记：尚硅谷Spring6基础篇
D_boj的博客
08-14 2444
本章介绍，Spring6基础使用、Spring的IOC原理、Spring6整合日志框架、容器IOC、面向切面AOP以及依赖注入的方式、自动装配和依赖注入等
Spring-尚硅谷-学习笔记
weixin_45581692的博客
10-10 6406
Spring框架是一个轻量级的开源的JavaEE框架。 Spring可以解决企业应用开发的复杂性。 Spring有两个核心部分：IOC和AOP IOC：控制反转，把创建对象的过程交给Spring AOP：面向切面，不修改源代码的情况下进行功能增强 Spring特点 方便解耦，简化开发 AOP编程支持 方便程序测试 方便和其他框架进行整合
学习笔记：尚硅谷Spring6进阶篇
D_boj的博客
08-14 1262
本章介绍，单元测试Junit、事务、资源操作：Resource、国际化：i18n、数据校验：Validation、提前编译：AOT以及ResourceLoader和Resource的实现类的区别
尚硅谷SpringCloud第二季笔记
01-22
【尚硅谷SpringCloud第二季笔记】是一份详细记录了SpringCloud组件使用的学习笔记，涵盖了SpringCloud在云原生环境下的核心概念和实践应用。SpringCloud是基于Spring Boot实现的微服务框架，它提供了构建分布式系统...
尚硅谷spring5视频笔记.zip
04-21
《尚硅谷spring5视频笔记》是一份详尽的Spring框架第五版的学习资料，它涵盖了Spring 5的关键概念、新特性和实战应用。Spring是Java领域中最流行的企业级应用框架之一，Spring 5作为其最新版本，引入了许多重要的...
尚硅谷周阳老师SpringCloud笔记
06-11
【尚硅谷周阳老师SpringCloud笔记】是一份深入学习SpringCloud技术体系的教程资源，由知名教育机构尚硅谷的周阳老师编撰。SpringCloud作为微服务架构的重要框架，广泛应用于现代企业的分布式系统开发中。这份笔记...
尚硅谷Spring Boot课堂笔记.rar
06-08
《尚硅谷Spring Boot课堂笔记》是一份详尽的Spring Boot学习资源，旨在帮助开发者深入理解和掌握这一现代Java应用开发框架。这份笔记源自尚硅谷教育机构的视频课程，视频链接为，涵盖了Spring Boot的基础知识到高级...
Spring5（尚硅谷笔记）
weixin_45787998的博客
08-04 1314
#补充笔记 1.IOC底层原理 1.IOC概念以及原理： 什么是ioc? 1.IOC(DI)概述： Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。 DI概述： DI—Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是
【视频分享】尚硅谷Java视频教程_SpringCloud视频教程
嘟爷java超神学堂
04-26 5421
尚硅谷SpringCloud第一手资料，分享给大家，祝大家走上技术巅峰后，可以来点赞赏。本套视频从面试题，到SpringCloud各种核心组件，到最终的微服务架构总结，帮...
【尚硅谷】spring学习笔记（1）：HelloWorld
猪猪
06-06 1396
1、安装SPRING TOOL SUITE 这个 Eclipse 插件。2、搭建spring开发环境，引入jar包。3、创建spring项目3.1、创建一个HelloWorld类public class HelloWorld { private String name; public void setName( String name) { this.name = name; }...
SpringBoot之@Validated校验List集合参数类型失效的解决方案
最新发布
一个人的博客
08-15 375
记录一下@Validated校验参数是List集合的时候会失效的解决方案
dubbo和springcloud有什么异同？
yszbrzdd的博客
08-15 481
Dubbo主要关注于高效的 RPC 调用和服务治理。提供了一个综合的微服务解决方案，涵盖了从服务注册到配置管理的广泛功能。它们可以根据具体需求和现有技术栈选择使用，也可以结合使用，例如在 Spring Cloud 环境中集成 Dubbo 作为 RPC 框架。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Mylife0506

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值