三大组件之Spring 第四章Spring与DAO

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

Spring与DAO

4.1 Spring 与 JDBC 模板

除了引入必要的jar包，还要导入sql数据库文件。

09-JDBC-Template
学生类 主要赋值三种属性

public class Student {
	private Integer id;
	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Integer getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	
	
	
}

学生方法的接口类

public interface IStudentService {
	void addStudent(Student student);
	void removeById(int id);
	void modifyStudent(Student student);
	
	List<String> findAllStudentsNames();
	String findStudentNameById(int id);
	
	List<Student> findAllStudents();
	Student findStudentById(int id);
}

学生方法的实现类
创建了DAO类对象，调用其方法返回值

public class StudentServiceImpl implements IStudentService {
	private IStudentDao dao;
	
	public void setDao(IStudentDao dao) {
		this.dao = dao;
	}

	@Override
	public void addStudent(Student student) {
		
		dao.insertStudent(student);
	}

	@Override
	public void removeById(int id) {
		dao.deleteById(id);

	}

	@Override
	public void modifyStudent(Student student) {
		dao.updateStudent(student);

	}

	@Override
	public List<String> findAllStudentsNames() {
		 
		return dao.selectAllStudentsNames();
	}

	@Override
	public String findStudentNameById(int id) {
		 
		return dao.selectStudentNameById(id);
	}

	@Override
	public List<Student> findAllStudents() {
		 
		return dao.selectAllStudents();
	}

	@Override
	public Student findStudentById(int id) {
		 
		return dao.selectStudentById(id);
	}

}

DAO接口类，各种查找方法

public interface IStudentDao {
	void insertStudent(Student student);
	void deleteById(int id);
	void updateStudent(Student student);
	
	List<String> selectAllStudentsNames();
	String selectStudentNameById(int id);
	
	List<Student> selectAllStudents();
	Student selectStudentById(int id);
}

DAO实现类并继承了JdbcDaoSupport来将sql语句写入jdbctemplate
实现了增删改查方法

public class StudentDaoImpl extends JdbcDaoSupport implements IStudentDao {

	@Override
	public void insertStudent(Student student) {
		String sql = "insert into student(name,age) values(?,?)";
		this.getJdbcTemplate().update(sql, student.getName(), student.getAge());

	}

	@Override
	public void deleteById(int id) {
		String sql = "delete from student where id = ?";
		this.getJdbcTemplate().update(sql, id);

	}

	@Override
	public void updateStudent(Student student) {
		String sql = "update student set name=?, age=? where id=?";
		this.getJdbcTemplate().update(sql, student.getName(), student.getAge(), student.getId());

	}

	//只查询所有名字
	@Override
	public List<String> selectAllStudentsNames() {
		String sql = "select name from student";
		return this.getJdbcTemplate().queryForList(sql, String.class);
	}

	//只查询指定id的名字
	@Override
	public String selectStudentNameById(int id) {
		String sql = "select name from student where id=?";
		return this.getJdbcTemplate().queryForObject(sql, String.class, id);
	}

	//查询多个目标
	@Override
	public List<Student> selectAllStudents() {
		String sql = "select id,name,age from student";
		return this.getJdbcTemplate().query(sql, new StudentRowMapper());
	}
	
	
	@Override
	public Student selectStudentById(int id) {
		String sql = "select id,name,age from student where id=?";
		return this.getJdbcTemplate().queryForObject(sql, new StudentRowMapper(), id);
	}

}

因为查询的方法中需要将多个属性赋给一个对象，所以我们用

pubic T queryForObject (String sql, RowMapper m , Object… args)
pubic List query (String sql, RowMapper m, Object… args)
注意，RowMapper 为记录映射接口，用于将查询结果集中每一条记录包装为指定对象。
该接口中有一个方法需要实现：
public Object mapRow(ResultSet rs, int rowNum)
参数 rowNum 表示总的结果集中当前行的行号，但参数 rs 并不表示总的结果集，而是
表示 rowNum 所代表的当前行的记录所定义的结果集，仅仅是当前行的结果。
一般，该方法体中就是实现将查询结果中当前行的数据包装为一个指定对象。

StudentRowMapper类 将多个属性赋给一个对象

public class StudentRowMapper implements RowMapper<Student> {

	 //rs:当查询出总的结果集后，框架会自动遍历这个结果集，每一次遍历的一行数据，都会被存放到
	// 这个方法的rs参数中。也就是说，这里的rs代表的是一行数据，并非所有查询结果。换个角度
	// 来说，只要能执行到这个方法，就说明这里的rs不会是空的
	@Override
	public Student mapRow(ResultSet rs, int arg1) throws SQLException {
		Student student = new Student();
		student.setId(rs.getInt("id"));
		student.setName(rs.getString("name"));
		student.setAge(rs.getInt("age"));
		
		return student;
	}

}

配置文件
1、C3P0数据源找到注册驱动driver、url定位符、用户名、密码四个连接属性。
2、从属性文件读取数据库连接信息，使用context:property-placeholder/ 方式导入属性配置文件，要求在 Spring 配置文件头部加入 context 的约束，在属性文件中给出四个属性的值。
3、把数据源赋给DAO类，会自动生成JDBC 模板对象。
4、把DAO类再给学生实现方法类

JDBC 模板类 JdbcTemplate 从其父类 JdbcAccessor 继承了一个属性 dataSource，用于接收
数据源。

<!-- 注册数据源：C3P0 -->
	<bean id="myDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driver}"/>
		<property name="jdbcUrl" value="${jdbc.url}"/>
		<property name="user" value="${jdbc.user}"/>
		<property name="password" value="${jdbc.password}"/>
	
	</bean>
	
	这里不用//<!-- 注册属性文件：方式一 
	<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="location" value="classpath:jdbc.properties"/>
	</bean>-->
	
	<!-- 注册属性文件：方式二 -->
	<context:property-placeholder location="classpath:jdbc.properties"/>
	
	这里不用//<!-- 注册JdbcTemplate和Dao 
	<bean id="myJdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="myDataSource"/>
	
	//</bean>
	
	//<bean id="studentDao" class="com.bjpowernode.dao.StudentDaoImpl">
		//<property name="jdbcTemplate" ref="myJdbcTemplate"/>
	
	//</bean> -->
	
	<!-- 注册Dao -->
	<bean id="studentDao" class="com.bjpowernode.dao.StudentDaoImpl">
		<property name="dataSource" ref="myDataSource"/>
	
	</bean>
	
	<!-- 注册Service -->
	<bean id="studentService" class="com.bjpwernode.service.StudentServiceImpl">
		<property name="dao" ref="studentDao"/>
	
	</bean>

jdbc.properties配置文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/test
jdbc.user=root
jdbc.password=333

测试代码：

public class MyTest {
		
	private IStudentService service;

	@Before
	public void before() {
		
		String resource = "applicationContext.xml";
		ApplicationContext ac = new ClassPathXmlApplicationContext(resource);
		service = (IStudentService) ac.getBean("studentService");
		
	}
	
	//增
	@Test
	public void test01() {
		
		Student student = new Student("张三", 23);
		service.addStudent(student);
		
	}
	
	//删
	@Test
	public void test02() {
		
		service.removeById(2);
		
	}
	
	//修改
	@Test
	public void test03() {
		
		Student student = new Student("张三", 23);
		student.setId(3);
		service.modifyStudent(student);
		
	}
	
	//查询
	@Test
	public void test04() {
		
		List<String> names = service.findAllStudentsNames();
		System.out.println(names);
	}
	@Test
	public void test05() {
		
		String name = service.findStudentNameById(3);
		System.out.println(name);
	}
	@Test
	public void test06() {
		
		List<Student> students = service.findAllStudents();
		for(Student student : students) {
			System.out.println(student);
		}
	}
	
	@Test
	public void test07() {
		Student student = service.findStudentById(3);
		System.out.println(student);
	}
}

可以使用Navicat查看结果

4.2 Spring的事务管理

举例：购买股票—transaction_buystock 项目
本例要实现模拟购买股票。存在两个实体：银行账户 Account 与股票账户 Stock。当要
购买股票时，需要从 Account 中扣除相应金额的存款，然后在 Stock 中增加相应的股票数量。
而在这个过程中，可能会抛出一个用户自定义的异常。异常的抛出，将会使两个操作回滚。

先建表
定义实体类账户

public class Account {
	private Integer aid;
	private String aname;
	private double balance; //余额
	public Account() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Account(String aname, double balance) {
		super();
		this.aname = aname;
		this.balance = balance;
	}
	public Integer getAid() {
		return aid;
	}
	public String getAname() {
		return aname;
	}
	public double getBalance() {
		return balance;
	}
	public void setAid(Integer aid) {
		this.aid = aid;
	}
	public void setAname(String aname) {
		this.aname = aname;
	}
	public void setBalance(double balance) {
		this.balance = balance;
	}
	
	 @Override public String toString() { return "Account [aid=" + aid +
	 ", aname=" + aname + ", balance=" + balance + "]"; }
		
	
}

定义实体类股票

public class Stock {
	private Integer sid;
	private String sname;  // 股票名称
	private int count;	   // 股票数量
	public Stock() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Stock(String sname, int count) {
		super();
		this.sname = sname;
		this.count = count;
	}
	public Integer getSid() {
		return sid;
	}
	public String getSname() {
		return sname;
	}
	public int getCount() {
		return count;
	}
	public void setSid(Integer sid) {
		this.sid = sid;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public void setCount(int count) {
		this.count = count;
	}
	@Override
	public String toString() {
		return "Stock [sid=" + sid + ", sname=" + sname + ", count=" + count + "]";
	}
	
	
}

定义Dao层实现股票和账户的增和改，这里接口类就省略了

public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {

	@Override
	public void insertAccount(String aname, double money) {
		String sql = "insert into account(aname, balance) values(?,?)";
		this.getJdbcTemplate().update(sql, aname, money);

	}

	@Override
	public void updateAccount(String aname, double money, boolean isBuy) {
		String sql = "update account set balance=balance+? where aname=?";
		if (isBuy) {
			sql = "update account set balance=balance-? where aname=?";
		}
		this.getJdbcTemplate().update(sql, money, aname);
	}

}

public class StockDaoImpl extends JdbcDaoSupport implements IStockDao {

	@Override
	public void insertStock(String sname, int amount) {
		
		String sql = "insert into stock(sname, count) values(?,?)";
		this.getJdbcTemplate().update(sql, sname, amount);

	}

	@Override
	public void updateStock(String sname, int amount, boolean isBuy) {
		String sql = "update stock set count=count-? where sname=?";
		if (isBuy) {
			sql = "update stock set count=count+? where sname=?";
		}
		this.getJdbcTemplate().update(sql, amount, sname);

	}

}

定义service实现类，这里同样省略了接口。调用了Dao类的方法，并设置了一个购买异常。

public class BuyStockServiceImpl implements IBuyStockService {
	private IAccountDao adao;
	private IStockDao sdao;
	
	
	
	public void setAdao(IAccountDao adao) {
		this.adao = adao;
	}

	public void setSdao(IStockDao sdao) {
		this.sdao = sdao;
	}

	@Override
	public void openAccount(String aname, double money) {
		adao.insertAccount(aname, money);
		

	}

	@Override
	public void openStock(String sname, int amount) {
		sdao.insertStock(sname, amount);

	}

	@Override
	public void buyStock(String aname, double money, String sname, int amount) throws BuyStockException{
		boolean isBuy = true;
		adao.updateAccount(aname, money, isBuy);
		if (1 == 1) {
			throw new BuyStockException("购买股票异常");
		}
		sdao.updateStock(sname, amount, isBuy);

	}

定义异常类

public class BuyStockException extends Exception {

	public BuyStockException() {
		super();
		// TODO Auto-generated constructor stub
	}

	public BuyStockException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}
	
}

jdbc配置文件同上
Spring配置文件：约束、xml注入、事务管理、AOP配置

<?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" 
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop.xsd">

	<!-- ======================= IoC ============================ -->
	
	<!-- 注册数据源：C3P0 -->
	<bean id="myDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driver}"/>
		<property name="jdbcUrl" value="${jdbc.url}"/>
		<property name="user" value="${jdbc.user}"/>
		<property name="password" value="${jdbc.password}"/>
	
	</bean>
	
	
	<!-- 注册属性文件 -->
	<context:property-placeholder location="classpath:jdbc.properties"/>
	
	<!-- 注册Dao -->
	<bean id="accountDao" class="com.bjpowernode.dao.AccountDaoImpl">
		<property name="dataSource" ref="myDataSource"/>
	
	</bean>
	<!-- 注册Dao -->
	<bean id="stockDao" class="com.bjpowernode.dao.StockDaoImpl">
		<property name="dataSource" ref="myDataSource"/>
	
	</bean>
	
	<!-- 注册Service -->
	<bean id="buyStockService" class="com.bjpowernode.service.BuyStockServiceImpl">
		<property name="adao" ref="accountDao"/>
		<property name="sdao" ref="stockDao"/>
	
	</bean>
	
	<!-- ======================= AOP ============================ -->
	
	<!-- 注册事务管理器 -->
	
	<bean id="myTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="myDataSource"/>
	</bean>
	
	<tx:advice id="txAdvice" transaction-manager="myTransactionManager">
		<tx:attributes>
			<!-- 这里指定的是：为每一个连接点指定所要应用的事务属性 -->
			<tx:method name="open*" isolation="DEFAULT" propagation="REQUIRED"/>
			<tx:method name="buyStock" isolation="DEFAULT" propagation="REQUIRED" rollback-for="BuyStockException"/>
		</tx:attributes>
	</tx:advice>
	
	<!-- AOP配置 -->
	<aop:config>
		<!-- 这里指定的是切入点 -->
		<aop:pointcut expression="execution(* *..service.*.*(..))" id="myPointcut"/>
		<aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut"/>
	
	</aop:config>
	
</beans>

测试类

public class MyTest {
		
	private IBuyStockService service;

	@Before
	public void before() {
		
		String resource = "applicationContext.xml";
		ApplicationContext ac = new ClassPathXmlApplicationContext(resource);
		service = (IBuyStockService) ac.getBean("buyStockService");
		
	}
	
	@Test
	public void test01() {
		service.openAccount("张三", 10000);
		service.openStock("北京动力节点", 0);

	}
	
	@Test
	public void test02() throws BuyStockException {
		service.buyStock("张三", 2000, "北京动力节点", 5);
		
		
	}
	
}
沐芳莫弹冠
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring dao层注解_Spring– DAO和服务层
最佳 Java 编程
06-04 9246
spring dao层注解 欢迎来到Spring教程的第三部分。 在这一部分中，我们将继续编写Timesheet应用程序，这次我们将实现DAO层，业务服务并编写一些测试。 在上一部分中，我们定义了GenericDao接口，该接口告诉我们需要对实体执行哪些操作。 现在我们需要提供实现。 我们将使用Hibernate的工具（使用SessionFactory）编写一个类来执行这些操作。 因此，任何...
java dao层 框架选择_SpringBoot框架中各层（DTO、DAO、Service、Controller）理解
weixin_34405769的博客
02-17 2363
粗略理解View层????Controller层(响应用户请求)????Service层(接口????接口实现类)????DAO层，即Mapper层(抽象类：xxxMapper.java文件，具体实现在xxxMapper.xml)????Model层(实体类：xxx.java)图解VO、DTO、DO、PO理解解释VO：View Object，视图层，其作用是将指定页面的展示数据封装起来。DTO：Data Transfer Ob...
Spring【DAO模块】就是这么简单
weixin_34009794的博客
03-15 271
前言 上一篇Spring博文主要讲解了如何使用Spring来实现AOP编程，本博文主要讲解Spring的DAO模块对JDBC的支持，以及Spring对事务的控制... 对于JDBC而言，我们肯定不会陌生，我们在初学的时候肯定写过非常非常多的JDBC模板代码！ 回顾对模版代码优化过程 我们来回忆一下我们怎么对模板代码进行优化的！ 首先来看一下我们原生的JDBC：需要手动去数据库的驱动从而拿到对应的...
DaoSupport 通用方法
tomfish
04-18 925
package com.hunqing.common.framework.dao; import java.io.Serializable; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import javax.persistence.Entity; import ja...
dao
javascript
12-26 154
DAO 模式理解 1.public class DAOSupport implements DAO 这个接口和其实现类定义出基本的数据库的操作方法 2.public class IMPSupport implements FacadeSupport { pr...
编写第一个 Spring MVC 程序
08-14
在本教程中，我们将详细讲解如何编写第一个 Spring MVC 程序，涵盖其核心概念、配置以及实现过程。 1. **Spring MVC 概述** Spring MVC 为 Web 开发提供了模型-视图-控制器（MVC）架构模式，它简化了业务逻辑与...
第一部分：Spring框架概述1
08-03
让我们深入探讨Spring的关键组件和功能。 1. **依赖注入（Dependency Injection, DI）与控制反转（Inversion of Control, IoC）** Spring的核心特性之一是IoC容器，它负责创建对象并管理它们之间的依赖关系。通过...
第七章 Spring4 继承、依赖、引用
04-30
4. **Spring的源码分析** 分析Spring的源码有助于深入理解其工作原理。例如，了解`DefaultListableBeanFactory`如何解析和管理Bean的定义，以及`ApplicationContext`如何加载和初始化Bean，这些都能帮助我们更好地...
Spring 3.x企业应用开发实战第17章
12-19
10. **Spring与第三方库集成**：Spring的强大之处在于其高度的可扩展性和与其他库的兼容性。本章可能提到了Spring与缓存系统（如 EhCache）、消息中间件（如ActiveMQ）或其他服务（如RESTful API）的集成。 以上...
Spring4.X教学视频
08-06
Spring框架是Java开发中最常用的轻量级开源框架之一，它以其强大的依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）能力深受开发者喜爱。Spring4.X作为其一个版本，引入了...
MyBatis之整合Spring（Dao和Mapper两种方式）
零度的博客专栏
09-18 7859
1. 基础环境搭建 　　首先环境肯定得有，环境嘛，除了Java环境和开发环境外，那就是jar包咯，关于mybatis和spring整合的jar包，我已经上传到下载频道了==>传送门  　　 将这些jar包导入到lib文件夹中即可，然后就是工程中的一些文件了，配置文件啊，java文件啊等，先看一下整个工程的结构。    　　下面来完成所有的整合步骤。  2. 配置文件 　　在
Spring与Dao
qq_43576155的博客
12-22 183
Spring于DAOSpring与DAOSpring与JDBC模板（对IOC的应用）对增删改的操作普通Bean的注册数据源的注册从属性连接读取DB的四要素将数据源注入给Daojdbc模板对象是多例的 Spring与DAO Spring与JDBC模板（对IOC的应用） 对增删改的操作 //对于增删改操作统一使用update @Override //增 public void insertStuden...
12 Spring框架 SpringDAO的事务管理
MindMrWang的blog
12-18 738
上一节我们说过Spring对DAO的两个支持分为两个知识点，一个是jdbc模板，另一个是事务管理。 事务是数据库中的概念，但是在一般情况下我们需要将事务提到业务层次，这样能够使得业务具有事务的特性，来管理业务。 例如：在银行的转账系统中，张三转账给李四，需要完成从张三的账户上扣取指定金额并加到李四的账户上，这样一个过程需要具有原子性，即要成功都成功，要失败都失败。转账的过程即两个对账户更新，需要
MyBatis-Spring整合
薛小强Forever
03-16 483
MyBatis-Spring会帮助你将MyBatis代码无缝地整合到Spring中。
【Spring实战】—— 14 传统的JDBC实现的DAO插入和读取
weixin_33852020的博客
02-03 79
从这篇开始学习Spring的JDBC，为了了解Spring对于JDBC的作用，先通过JDBC传统的流程，实现一个数据库的插入和读取。 　　从这篇你可以了解到： 　　1 传统的JDBC插入和读取的过程。 　　2 如何通过JDBC连接Mysql 　　如何通过JDBC连接mysql 　　首先看一下下面这张图： 　　应用程序需要通过mysql的驱动程序，才能与数据连接。 　　驱动...
Spring5学习笔记（五、MVC框架整合）
小楊同学的笔记本
10-25 226
文章目录MVC框架整合思想搭建Web运行环境为什么要整合MVC框架？Spring可以整合哪些MVC框架？Spring整合MVC框架的核心思路六、注解编程 MVC框架整合思想 搭建Web运行环境 在main包下创建java包和resources包。 引入jar包 <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <!--修改为
spring 如何将spring中的dao、service等注入到普通的Java类
weixin_30780649的博客
06-08 266
　　在spring管理的项目里，譬如springboot、springmvc等的项目，配置好后，springboot里就可以直接使用定义好的service、dao。但是如果要在普通的工具类里，使用service、dao，就会报空指针，因为这个普通的java类并不在spring管理下，不能使用spring注入的service、dao。 　　那么该怎么办呢，下面就来分享几种方法：手动获取spring...
免费【2024】springboot 二手图书交易系统的设计与实现
weixin_53646065的博客
08-05 912
随着世界经济信息化、全球化的到来和互联网的飞速发展，推动了各行业的改革。若想达到安全，快捷的目的，就需要拥有信息化的组织和管理模式，建立一套合理、动态的、交互友好的、高效的二手图书交易系统。当前的信息管理存在工作效率低，工作繁杂等问题，基于信息化的二手图书交易管理目前还没有完善的系统机制。
使用Spring与JDK动态代理实现事务管理
最新发布
面团到油条的成长日记
08-08 732
使用Spring与JDK动态代理实现事务管理，带你更加了解代理模式的应用
Spring实战第三版：核心模块与应用集成详解
- **第4章至第14章：Aspect-oriented programming (AOP)**：涉及面向切面编程，用于处理如事务管理、安全性、远程服务调用等跨层关注点。 **第二部分：Spring应用程序基础** - **第5章：Hitting the Database**：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值