Spring框架教程

最新推荐文章于 2024-08-01 22:00:59 发布

2301_82242459

最新推荐文章于 2024-08-01 22:00:59 发布

阅读量411

点赞数 5

分类专栏： 2024年程序员学习文章标签： spring windows java

本文链接：https://blog.csdn.net/2301_82242459/article/details/137689281

版权

2024年程序员学习专栏收录该内容

92 篇文章 1 订阅

订阅专栏

3.4.4 注入空值和特殊符号

<![CDATA[<<南京>>]]>

3.4.5 注入属性-外部bean

public class UserService {//service类

//创建UserDao类型属性，生成set方法
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}

public void add() {
System.out.println(“service add…”);
userDao.update();//调用dao方法
}
}

public class UserDaoImpl implements UserDao {//dao类

@Override
public void update() {
System.out.println(“dao update…”);
}
}

配置类：

3.4.6 基于XML方式注入内部bean和级联赋值

（1）一对多关系：部门和员工
一个部门有多个员工，一个员工属于一个部门（部门是一，员工是多）
（2）在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示

//部门类
public class Dept {
private String dname;
public void setDname(String dname) {
this.dname = dname;
}
}

//员工类
public class Emp {
private String ename;
private String gender;
//员工属于某一个部门，使用对象形式表示
private Dept dept;

public void setDept(Dept dept) {
this.dept = dept;
}
public void setEname(String ename) {
this.ename = ename;
}
public void setGender(String gender) {
this.gender = gender;
}
}

配置类

//方式二：生成dept的get方法（get方法必须有！！）
public Dept getDept() {
return dept;
}

3.4.7 xml 注入集合属性

//（1）创建类，定义数组、list、map、set 类型属性，生成对应 set 方法
public class Stu {
//1 数组类型属性
private String[] courses;
//2 list集合类型属性
private List list;
//3 map集合类型属性
private Map<String,String> maps;
//4 set集合类型属性
private Set sets;

public void setSets(Set sets) {
this.sets = sets;
}
public void setCourses(String[] courses) {
this.courses = courses;
}
public void setList(List list) {
this.list = list;
}
public void setMaps(Map<String, String> maps) {
this.maps = maps;
}

java课程数据库课程张三小三 MySQL Redis

3.4.8 在集合里面设置对象类型值

//学生所学多门课程
private List courseList;//创建集合
public void setCourseList(List courseList) {
this.courseList = courseList;
}

3.4.9 把集合注入部分提取出来

<?xml version="1.0" encoding="UTF-8"?>

<util:list id=“bookList”>
易筋经
九阴真经
九阳神功
</util:list>

3.5 xml方式实现Bean管理高级

3.5.1 IOC 操作 Bean 管理（FactoryBean）

1、Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）
2、普通 bean：在配置文件中定义 bean 类型就是返回类型
3、工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样第一步创建类，让这个类作为工厂 bean，实现接口 FactoryBean 第二步实现接口里面的方法，在实现的方法中定义返回的 bean 类型

public class MyBean implements FactoryBean {

//定义返回bean
@Override
public Course getObject() throws Exception {
Course course = new Course();
course.setCname(“abc”);
return course;
}
}

配置类

测试类

@Test
public void test3() {
ApplicationContext context =
new ClassPathXmlApplicationContext(“bean3.xml”);
//xml里定义的是MyBean类型的，而返回值是Course类型的
Course course = context.getBean(“myBean”, Course.class);//返回值类型可以不是定义的bean类型！
System.out.println(course);
}

3.5.2 IOC 操作 Bean 管理（bean 作用域）

（1）在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例
（2）scope 属性值第一个值默认值，singleton，表示是单实例对象第二个值 prototype，表示是多实例对象
（3）singleton 和 prototype 区别

（a）singleton 单实例，prototype 多实例
（b）设置 scope 值是 singleton 时候，加载 spring 配置文件时候就会创建单实例对象；设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建对象，在调用 getBean 方法时候创建多实例对象

（4）Spring中Bean默认是单实例的

3.5.3 IOC 操作 Bean 管理（bean 生命周期）

生命周期概念：从对象创建到对象销毁的过程

bean 生命周期：

（1）通过构造器创建 bean 实例（无参数构造）

（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）

（3）调用 bean 的初始化的方法（需要进行配置初始化的方法）

（4）bean 可以使用了（对象获取到了）

（5）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

演示 bean 生命周期：

public class Orders {
//无参数构造
public Orders() {
System.out.println(“第一步执行无参数构造创建 bean 实例”);
}
private String oname;
public void setOname(String oname) {
this.oname = oname;
System.out.println(“第二步调用 set 方法设置属性值”);
}
//创建执行的初始化的方法
public void initMethod() {
System.out.println(“第三步执行初始化的方法”);
}
//创建执行的销毁的方法
public void destroyMethod() {
System.out.println(“第五步执行销毁的方法”);
}
}

配置类

测试类

@Test
public void testBean3() {
// ApplicationContext context =
// new ClassPathXmlApplicationContext(“bean4.xml”);
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext(“bean4.xml”);
Orders orders = context.getBean(“orders”, Orders.class);
System.out.println(“第四步获取创建 bean 实例对象”);
System.out.println(orders);
//手动让 bean 实例销毁
context.close();
}

bean 的后置处理器， bean 生命周期有七步：

（1）通过构造器创建 bean 实例（无参数构造）

（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）

**（3）把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization **

（4）调用 bean 的初始化的方法（需要进行配置初始化的方法）

**（ 5）把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization **

（6） bean 可以使用了（对象获取到了）

（7）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

public class MyBeanPost implements BeanPostProcessor {//创建后置处理器实现类
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println(“在初始化之前执行的方法”);
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println(“在初始化之后执行的方法”);
return bean;
}
}

配置类

测试类

3.5.4 IOC 操作 Bean 管理（ xml 自动装配）

1、什么是自动装配

（1）根据指定装配规则（属性名称或者属性类型）， Spring 自动将匹配的属性值进行注入

2、演示自动装配过程

（1）根据属性名称自动注入

（2）根据属性类型自动注入

3.5.5 IOC 操作 Bean 管理(外部属性文件)

方式一：直接配置数据库信息：

（1）配置Druid（德鲁伊）连接池

（2）引入Druid（德鲁伊）连接池依赖 jar 包

方式二：引入外部属性文件配置数据库连接池

（1）创建外部属性文件，properties 格式文件，写数据库信息（jdbc.properties）

//jdbc.properties
prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.userName=root
prop.password=root

（2）把外部 properties 属性文件引入到 spring 配置文件中 —— 引入 context 名称空间

<context:property-placeholder location=“classpath:jdbc.properties”/>

3.6 注解方式实现Bean管理

3.6.1 什么是注解

（1）注解是代码特殊标记，格式： @注解名称(属性名称=属性值, 属性名称=属性值…)

（2）使用注解，注解作用在类上面，方法上面，属性上面

（3）使用注解目的：简化 xml 配置

3.6.2 Spring 针对 Bean 管理中创建对象提供注解

（1） @Component

（2） @Service

（3） @Controller

（4） @Repository

上面四个注解功能是一样的，都可以用来创建 bean 实例

3.6.3 基于注解方式实现对象创建

（a）开启组件扫描

<context:component-scan base-package=“com.atguigu”></context:component-scan>

（b）创建类，在类上面添加创建对象注解

//在注解里面 value 属性值可以省略不写，
//默认值是类名称，首字母小写
//UserService – userService@Component(value = “userService”) //
public class UserService {
public void add() {
System.out.println(“service add…”);
}
}

（c）组件扫描的细节配置

<context:component-scan base-package=“com.atguigu” use-defaultfilters=“false”>
<context:include-filter type=“annotation”
expression=“org.springframework.stereotype.Controller”/>
</context:component-scan>

<context:component-scan base-package=“com.atguigu”>
<context:exclude-filter type=“annotation”
expression=“org.springframework.stereotype.Controller”/>
</context:component-scan>

（d）基于注解方式实现属性注入

@Autowired：根据类型注入

@Service
public class UserService {
//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired
private UserDao userDao;
public void add() {
System.out.println(“service add…”);
userDao.add();
}
}

@Qualifier：根据名称进行注入

这个@Qualifier 注解的使用，和上面@Autowired 一起使用

//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired //根据类型进行注入
@Qualifier(value = “userDaoImpl1”) //根据名称进行注入
private UserDao userDao;

@Resource：可以根据类型注入，可以根据名称注入

//@Resource
//根据类型进行注入
@Resource(name = “userDaoImpl1”)
//根据名称进行注入
private UserDao userDao;

@Value：注入普通类型属性

@Value(value = “abc”)
private String name;

（e）完全注解开发

配置类

@Configuration //作为配置类，替代 xml 配置文件
@ComponentScan(basePackages = {“com.atguigu”})
public class SpringConfig {
}

测试类

@Test
public void testService2() {
//加载配置类
ApplicationContext context
= new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = context.getBean(“userService”,UserService.class);
System.out.println(userService);
userService.add();
}

4. AOP面向切面编程

ioc为控制反转，把创建对象过程交给spring进行管理
aop 的概念为面向切面，不修改源代码进行功能增强
可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率

4.1 底层原理

底层通过动态代理来实现：

第一种：有接口的情况，使用JDK动态代理：创建接口实现类的代理对象。
在这里插入图片描述

第二种：无接口的情况，使用CGLIB动态代理：创建当前类子类的代理对象。

在这里插入图片描述

4.2 jdk动态代理

所谓的代理：为真实对象提供一个代理对象以控制对真实对象的访问

动态代理主要涉及两个类：

public Object invoke(Object obj,Method method, Object[] args)
obj指代理类，method是被代理的方法，args为该方法的参数数组。这个抽象方法在代理类中动态实现
主要传参数通过method中的一个invoke的方法
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
类加载器(class loader)、Class对象数组（每个元素都是需要实现的接口）、一个调用处理器
所谓的jdk动态代理

使用 Proxy 类里面的方法创建代理对象
类中有个方法为

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

具体有三个参数，分别为

类加载器
增强方法所在的类，这个类实现的接口，支持多个接口
实现这个接口 InvocationHandler，创建代理对象，写增强的部分
代理对象，所以类似之前的多态

通过代码示列展示实现过程

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

public interface UserDao {
public int add(int a,int b);
public String update(String id);
}

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

public class UserDaoImpl implements UserDao {
@Override
public int add(int a, int b) {
return a+b;
}
@Override
public String update(String id) {
return id;
} }

（3）使用 Proxy 类创建接口代理对象
简化版本：

public class JDKProxy {

public static void main(String[] args) {
//创建接口实现类代理对象
Class[] interfaces = {UserDao.class};
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return null;
}
});

}
}

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

//增强的逻辑
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

//被增强的方法执行
Object res = method.invoke(obj, args);

return res;
}
}

结合实际代码的复杂逻辑：

public class JDKProxy {

public static void main(String[] args) {
//创建接口实现类代理对象
Class[] interfaces = {UserDao.class};

//因为是有参构造，需要把参数传递过来
//因为是代理对象，所以类似之前的多态
UserDaoImpl userDao = new UserDaoImpl();
UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
int result = dao.add(1, 2);
System.out.println(“result:”+result);
}
}

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

//1 把创建的是谁的代理对象，把谁传递过来
//有参数构造传递
private Object obj;
public UserDaoProxy(Object obj) {
this.obj = obj;
}

//增强的逻辑
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//方法之前
System.out.println(“方法之前执行…”+method.getName()+" :传递的参数…"+ Arrays.toString(args));

//被增强的方法执行
Object res = method.invoke(obj, args);

//方法之后
System.out.println(“方法之后执行…”+obj);
return res;
}
}

4.3 相关术语

连接点：类中有哪些方法可以被增强，这些方法称之为连接点
切入点：实际被增强的方法
通知（增强）：实际增强的逻辑部分称之为通知（增强）
通知有多种类型：前置通知、后置通知、环绕通知（前后执行）、异常通知（只有异常才会通知）、最终通知（类似finally）
切面：把通知应用到切入点的过程，是一个动作的过程

4.4 准备工作

Spring 框架一般都是基于 AspectJ 实现 AOP 操作
基于 AspectJ 实现 AOP 操作有两种：
基于 xml 配置文件实现
基于注解方式实现（使用）
在项目工程里面引入 AOP 相关依赖
切入点表达式（对哪个类里面的哪个方法进行增强）
语法结构： 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.*.* (..))

4.5 AspectJ注解操作

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

//被增强的类
@Component
public class User {
public void add() {
int i = 10/0;
System.out.println(“add…”);
}
}

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

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

进行通知配置

开启注解扫描

<context:component-scan base-package=“com.atguigu.spring5.aopanno”></context:component-scan>

aop:aspectj-autoproxy</aop:aspectj-autoproxy>

注：

使用注解创建 User 和 UserProxy 对象@Component
在增强类上面添加注解 @Aspect，生成代理对象
在 spring 配置文件中开启生成代理对象
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>，主要是查找注解@Aspect

配置不同类型的通知

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

//相同切入点抽取
@Pointcut(value = “execution(* com.atguigu.spring5.aopanno.User.add(…))”)
public void pointdemo() {

}

//前置通知
//@Before注解表示作为前置通知
@Before(value = “pointdemo()”)
public void before() {
System.out.println(“before…”);
}

//后置通知（返回通知）
@AfterReturning(value = “execution(* com.atguigu.spring5.aopanno.User.add(…))”)
public void afterReturning() {
System.out.println(“afterReturning…”);
}

//最终通知
@After(value = “execution(* com.atguigu.spring5.aopanno.User.add(…))”)
public void after() {
System.out.println(“after…”);
}

//异常通知
@AfterThrowing(value = “execution(* com.atguigu.spring5.aopanno.User.add(…))”)
public void afterThrowing() {
System.out.println(“afterThrowing…”);
}

//环绕通知
@Around(value = “execution(* com.atguigu.spring5.aopanno.User.add(…))”)
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println(“环绕之前…”);

//被增强的方法执行
proceedingJoinPoint.proceed();

System.out.println(“环绕之后…”);
}
}

注：

proceedingJoinPoint.proceed();执行被增强的方法，通常是放在@Around，主要是前后执行
after是方法之后执行，有没有异常都执行
AfterThrowing是返回值之后执行，有异常之后不执行

注：

公共切入点的提取

在相同切入点进行提取
只需调用其方法即可

//相同切入点抽取
@Pointcut(value = “execution(* com.atguigu.spring5.aopanno.User.add(…))”)
public void pointdemo() {

}
//前置通知
//@Before注解表示作为前置通知
@Before(value = “pointdemo()”)
public void before() {
System.out.println(“before…”);
}

有多个增强类多同一个方法进行增强，设置增强类优先级
在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高

@Component
@Aspect
@Order(1)

完全使用注解开发
创建配置类，不需要创建 xml 配置文件

组件的扫描@ComponentScan(basePackages = {"com.atguigu"})等同于

<context:component-scan base-package=“com.atguigu.spring5.aopanno”></context:component-scan>

生成代理对象@EnableAspectJAutoProxy(proxyTargetClass = true)等同于

aop:aspectj-autoproxy</aop:aspectj-autoproxy>

@Configuration
@ComponentScan(basePackages = {“com.atguigu”})
@EnableAspectJAutoProxy(proxyTargetClass = true)//默认为true

测试类

@Test
public void testAopAnno() {
ApplicationContext context =
new ClassPathXmlApplicationContext(“bean1.xml”);
User user = context.getBean(“user”, User.class);
user.add();
}

4.6 AspectJ配置文件

配置文件一般很少用
一开始还是创建两个类，增强类和被增强类，创建方法

public class Book {
public void buy() {
System.out.println(“buy…”);
}
}

public class BookProxy {
public void before() {
System.out.println(“before…”);
}
}

主要区分是配置文件的不同和没有注解方式
下面主要讲解配置文件的格式

通过bean id class 创建对象
通过aop config的配置文件配置切入点（增加的类）以及切入面（增强的方法）

aop:config

<aop:pointcut id=“p” expression=“execution(* com.atguigu.spring5.aopxml.Book.buy(…))”/>

<aop:aspect ref=“bookProxy”>

<aop:before method=“before” pointcut-ref=“p”/>
</aop:aspect>
</aop:config>

配置类

aop:config

<aop:pointcut id=“p” expression=“execution(* 全限定名称路径名.buy(…))”/>

<aop:aspect ref=“类名”>

<aop:before method=“方法名” pointcut-ref=“p”/>
</aop:aspect>
</aop:config>

测试类

@Test
public void testAopXml() {
ApplicationContext context =
new ClassPathXmlApplicationContext(“bean2.xml”);
Book book = context.getBean(“book”, Book.class);
book.buy();
}

输出

before…
buy…

如果修改配置文件的切入点，在切入点中修改切入面（即实际增强的部分）
ref为实际增强的类，method为方法名，pointcut-ref为切入点与切入面连接的点

<aop:aspect ref=“bookProxy”>

<aop:after method=“after” pointcut-ref=“p”/>
</aop:aspect>

输出

buy…
after…

5. JdbcTemplate

1、spring配置文件的数据库配置信息

destroy-method=“close”>

2、配置 JdbcTemplate 对象，注入 DataSource

在这里插入图片描述

3、创建 service 类，配置dao对象，创建 dao 类，在 dao 注入 jdbcTemplate 对象
开启组件扫描

<context:component-scan base-package=“com.atguigu”></context:component-scan>

service中配置dao对象类，要配置一个注解类通过@Service
使用@Autowired进行注入对象

@Service

public class UserService {

//注入dao
@Autowired
private UserDao userDao;
}

在dao中配置jdbcTemplate 对象
通过@Repository进行标识

@Repository
public class UserDaoImpl implements UserDao {

@Autowired
private JdbcTemplate jdbcTemplate;

5.1 JdbcTemplate 操作数据库（添加）

DaoImpl需要有jdbcTemplate对象，Service需要有Dao对象

（1）对应数据库的实体类

public class Book {
private String userId;
private String username;
private String ustatus;

@Override
public String toString() {
return “Book{” +
“userId='” + userId + ‘’’ +
“, username='” + username + ‘’’ +
“, ustatus='” + ustatus + ‘’’ +
‘}’;
}

public String getUserId() {
return userId;
}

public void setUserId(String userId) {
this.userId = userId;
}

public String getUsername() {
return username;
}

public void setUsername(String username) {
this.username = username;
}

public Book(String userId, String username, String ustatus) {
this.userId = userId;
this.username = username;
this.ustatus = ustatus;
}

public Book() {
}

public String getUstatus() {
return ustatus;
}

public void setUstatus(String ustatus) {
this.ustatus = ustatus;
}
}

（2）编写Service和Dao

public interface BookDao {
public void add(Book book);

void delete(String id);

void update(Book book);

int selectCount();

Book selectBookInfo(String id);

List selectAllBook();

void batchAdd(List<Object[]> batchArgs);

void batchUpdateBook(List<Object[]> batchArgs);

void batchDeleteBook(List<Object[]> batchArgs);
}

@Repository
public class BookDaoImpl implements BookDao{
@Autowired
private JdbcTemplate jdbcTemplate;
}

@Service
public class BookService {

@Autowired
private BookDao bookDao;

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

//删除
public void delete(String id){
bookDao.delete(id);
}

//修改
public void update(Book book){
bookDao.update(book);
}

//查询1
public int selectCount(){
return bookDao.selectCount();
}

//查询2
public Book selectBookInfo(String id){
return bookDao.selectBookInfo(id);
}

//查询3
public List selectAllBook(){
return bookDao.selectAllBook();
}

//批量添加
public void batchAdd(List<Object[]> batchArgs){
bookDao.batchAdd(batchArgs);
}

//批量修改
public void batchUpdateBook(List<Object[]> batchArgs){
bookDao.batchUpdateBook(batchArgs);
}

//批量删除
public void batchDeleteBook(List<Object[]> batchArgs){
bookDao.batchDeleteBook(batchArgs);
}
}

@Repository
public class BookDaoImpl implements BookDao {
//注入 JdbcTemplate
@Autowired
private JdbcTemplate jdbcTemplate;
//添加的方法
@Override
public void add(Book book) {
//1 创建 sql 语句
String sql = “insert into t_book values(?,?,?)”;
//2 调用方法实现
Object[] args = {book.getUserId(), book.getUsername(),book.getUstatus()};
int update = jdbcTemplate.update(sql,args);
System.out.println(update);
}
}

测试类

@Test
public void testJdbcTemplate() {
ApplicationContext context =
new ClassPathXmlApplicationContext(“bean1.xml”);
BookService bookService = context.getBean(“bookService”,
BookService.class);
Book book = new Book();
book.setUserId(“1”);
book.setUsername(“java”);
book.setUstatus(“a”);
bookService.addBook(book);
}

5.2 JdbcTemplate 操作数据库（修改和删除）

使用JdbcTemplate 模板所实现的 “增删改” 都是调用了同一个 “update” 方法

//1、修改
@Override
public void updateBook(Book book) {
String sql = “update t_book set username=?,ustatus=? where user_id=?”;
Object[] args = {book.getUsername(), book.getUstatus(),book.getUserId()};
int update = jdbcTemplate.update(sql, args);
System.out.println(update);
}
//2、删除
@Override
public void delete(String id) {
String sql = “delete from t_book where user_id=?”;
int update = jdbcTemplate.update(sql, id);
System.out.println(update);
}

5.3 JdbcTemplate 操作数据库（查询返回某个值）

//查询表记录数
@Override
public int selectCount() {
String sql = “select count(*) from t_book”;
//queryForObject方法中：第一个参数代表–sql语句；第二个参数代表–返回类型class
Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
return count;
}

5.4 JdbcTemplate 操作数据库（查询返回集合）

//所用场景：查询图书列表分页、、
//查询返回集合
@Override
public List findAllBook() {
String sql = “select * from t_book”;
//调用方法
List bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper(Book.class));
return bookList;
}

5.4 JdbcTemplate 操作数据库（批量操作）

//批量添加
@Override
public void batchAddBook(List<Object[]> batchArgs) {
String sql = “insert into t_book values(?,?,?)”;
//batchUpdate方法第一个参数：sql语句第二个参数：List集合，添加多条记录数据
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
System.out.println(Arrays.toString(ints));
}

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

5.5 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));
}

6. 事务

6.1 什么是事务？

（ 1）事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败

（2）典型场景：银行转账 lucy 转账 100 元给 mary lucy 少 100， mary 多 100

6.2 事务四个特性（ACID）

（1）原子性

（2）一致性

（3）隔离性

（4）持久性

6.3 事务操作

（模拟事务操作环境）

public interface UserDao {
/**

减少钱
*/
void redeceMoney();

/**

添加钱
*/
void addMoney();
}

@Repository
public class UserDaoImpl implements UserDao{

@Autowired
private JdbcTemplate jdbcTemplate;
/**

减少钱
*/
@Override
public void redeceMoney() {
String sql = “update t_account set money = money - ? where username = ?”;
jdbcTemplate.update(sql, 100, “lucy”);
}

/**

添加钱
*/
@Override
public void addMoney() {
String sql = “update t_account set money = money + ? where username = ?”;
jdbcTemplate.update(sql, 100, “mary”);
}
}

@Service
public class UserService {

@Autowired
private UserDao userDao;

public void accountMoney(){
//lucy给mary转100元
userDao.redeceMoney();
userDao.addMoney();
}

}

上边代码正常执行没有问题，但是如果代码执行过程中出现异常，有问题，如下模拟异常！

@Service
public class UserService {
//这里执行后将会产生错误（异常），lucy 少 100后，mary不会多 100，这就不对了！！
private UserDao userDao;
//转账方法
public void accountMoney(){
userDao.reduceMoney();//lucy 少 100

//模拟异常
int x=10/0;

userDao.addMoney(); //mary 多 100
}
}

解决方式

//解决上边的异常方法——【编程式事务（传统方法）】
//转账的方法
public void accountMoney() {
try {
//第一步开启事务

//第二步进行业务操作
//lucy少100
userDao.reduceMoney();

//模拟异常
int i = 10/0;

//mary多100

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Go语言工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Go语言全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Golang知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Go）

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

d
private JdbcTemplate jdbcTemplate;
/**

减少钱
*/
@Override
public void redeceMoney() {
String sql = “update t_account set money = money - ? where username = ?”;
jdbcTemplate.update(sql, 100, “lucy”);
}

/**

添加钱
*/
@Override
public void addMoney() {
String sql = “update t_account set money = money + ? where username = ?”;
jdbcTemplate.update(sql, 100, “mary”);
}
}