童小纯
童小纯

Spring-全面详解（学习总结---从入门到深化）

目录

Spring简介

 Spring体系结构

IOC_控制反转思想 

IOC_自定义对象容器

 IOC_Spring实现IOC

 IOC_Spring容器类型                                                                     ​                

容器实现类

 IOC_对象的创建方式

使用构造方法

使用工厂类的方法

使用工厂类的静态方法

IOC_对象的创建策略

 IOC_对象的销毁时机

 IOC_生命周期方法

IOC_获取Bean对象的方式

通过id/name获取

通过类型获取

通过类型+id/name获取

DI_什么是依赖注入

DI_依赖注入方式

Setter注入

构造方法注入

自动注入

DI_依赖注入类型

注入bean类型

注入基本数据类型

注入List集合

注入Set集合

注入Map集合

注入Properties对象

注解实现IOC_准备工作

注解实现IOC_@Component

 注解实现IOC_@Repository、@Service、@Controller

注解实现IOC_@Scope

注解实现IOC_@Autowired 

注解实现IOC_@Qualifier 

注解实现IOC_@Value

注解实现IOC_@Configuration 

注解实现IOC_@ComponentScan

 注解实现IOC_@PropertySource

注解实现IOC_@Bean

注解实现IOC_@Import 

Spring整合MyBatis_搭建环境

创建maven项目，引入依赖。

Spring整合MyBatis_编写配置文件

 1、编写数据库配置文件db.properties

 Spring整合MyBatis_准备数据库和实体类

准备数据库

准备实体类

Spring整合MyBatis_编写持久层接口和service类

编写持久层接口

编写service类

Spring整合MyBatis_Spring整合Junit进行单元测试

Spring整合MyBatis_自动创建代理对象 

SpringAOP_AOP简介 

 SpringAOP_AOP相关术语

 SpringAOP_AOP入门

 SpringAOP_通知类型

SpringAOP_切点表达式 

SpringAOP_多切面配置 

 SpringAOP_注解配置AOP

SpringAOP_原生Spring实现AOP

SpringAOP_SchemaBased实现AOP 

Spring事务_事务简介

Spring事务_Spring事务管理方案 

 Spring事务_Spring事务管理器

Spring事务_事务控制的API

Spring事务_事务的相关配置 

 Spring事务_事务的传播行为

Spring事务_事务的隔离级别 

 Spring事务_注解配置声明式事务

Spring简介

Spring-全面详解（学习总结---从入门到深化）_第1张图片

 Spring是一个开源框架，为简化企业级开发而生。它以IOC（控制 反转）和AOP（面向切面）为思想内核，提供了控制层 SpringMVC、数据层SpringData、服务层事务管理等众多技术，并 可以整合众多第三方框架。 Spring将很多复杂的代码变得优雅简洁，有效的降低代码的耦合 度，极大的方便项目的后期维护、升级和扩展。

Spring官网地址：https://spring.io/

 Spring体系结构

Spring-全面详解（学习总结---从入门到深化）_第2张图片

 Spring框架根据不同的功能被划分成了多个模块，这些模块可以满 足一切企业级应用开发的需求，在开发过程中可以根据需求有选择 性地使用所需要的模块。

1、Core Container：Spring核心模块，任何功能的使用都离不开该模块，是其他模块建立的基础。

2、Data Access/Integration：该模块提供了数据持久化的相应功能。

3、Web：该模块提供了web开发的相应功能。

4、AOP：提供了面向切面编程实现

5、Aspects：提供与AspectJ框架的集成，该框架是一个面向切面编程框架。

6、Instrumentation：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使 用。

7、Messaging：为Spring框架集成一些基础的报文传送应用

8、Test：提供与测试框架的集成

IOC_控制反转思想 

Spring-全面详解（学习总结---从入门到深化）_第3张图片

 IOC(Inversion of Control) ：程序将创建对象的权利交给框架。 之前在开发过程中，对象实例的创建是由调用者管理的，代码如下：

public interface StudentDao {
    // 根据id查询学生
    Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟从数据库查找出学生
        return new Student(1,"程序员","北京");
   }
}
public class StudentService {
    public Student findStudentById(int id){
        // 此处就是调用者在创建对象
        StudentDao studentDao = new StudentDaoImpl();
        return studentDao.findById(1);
   }
}

这种写法有两个缺点：

1 浪费资源：StudentService调用方法时即会创建一个对象，如果 不断调用方法则会创建大量StudentDao对象。

2 代码耦合度高：假设随着开发，我们创建了StudentDao另一个 更加完善的实现类StudentDaoImpl2，如果在StudentService 中想使用StudentDaoImpl2，则必须修改源码。

而IOC思想是将创建对象的权利交给框架，框架会帮助我们创建对 象，分配对象的使用，控制权由程序代码转移到了框架中，控制权 发生了反转，这就是Spring的IOC思想。而IOC思想可以完美的解决以上两个问题。 

IOC_自定义对象容器

Spring-全面详解（学习总结---从入门到深化）_第4张图片

 接下来我们通过一段代码模拟IOC思想。创建一个集合容器，先将 对象创建出来放到容器中，需要使用对象时，只需要从容器中获取 对象即可，而不需要重新创建，此时容器就是对象的管理者。

创建实体类

public class Student {
    private int id;
    private String name;
    private String address;
 // 省略getter/setter/构造方法/tostring
}

创建Dao接口和实现类

public interface StudentDao {
    // 根据id查询学生
    Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟从数据库查找出学生
        return new Student(1,"程序员","北京");
   }
}
public class StudentDaoImpl2 implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟根据id查询学生
        System.out.println("新方法！！！");
        return new Student(1,"程序员","北京");
   }
}

创建配置文件bean.properties，该文件中定义管理的对象

studentDao=com.itbaizhan.dao.StudentDaoImpl

创建容器管理类，该类在类加载时读取配置文件，将配置文件中 配置的对象全部创建并放入容器中。

public class Container {
    static Map map = new HashMap();
    static {
        // 读取配置文件
        InputStream is = Container.class.getClassLoader().getResourceAsStream("bean.properties");
        Properties properties = new Properties();
        try {
            properties.load(is);
       } catch (IOException e) {
            e.printStackTrace();
       }
        // 遍历配置文件的所有配置
        Enumeration keys = properties.keys();
        while (keys.hasMoreElements()){
            String key = keys.nextElement().toString();
            String value = properties.getProperty(key);
            try {
                // 创建对象
                Object o = Class.forName(value).newInstance();
                // 将对象放入集合中
                map.put(key,o);
           } catch (Exception e) {
                e.printStackTrace();
           }
       }
   }
    // 从容器中获取对象
 public static Object getBean(String key){
        return map.get(key);
   }
} 
  
创建Dao对象的调用者StudentService
 
  
public class StudentService {
    public Student findStudentById(int id)
     {
        // 从容器中获取对象
        StudentDao studentDao = (StudentDao) Container.getBean("studentDao");
        System.out.println(studentDao.hashCode());
        return studentDao.findById(id);
   }
}
 
  
测试StudentService
 
  
public class Test {
    public static void main(String[] args)
    {
      StudentService studentService = new StudentService();
      System.out.println(studentService.findStudentById(1));
      System.out.println(studentService.findStudentById(1));
   }
}
 
  
Spring-全面详解（学习总结---从入门到深化）_第5张图片
 
  
 IOC_Spring实现IOC
 
  
Spring-全面详解（学习总结---从入门到深化）_第6张图片
 
  
 接下来我们使用Spring实现IOC，Spring内部也有一个容器用来管 理对象。
 
  
创建Maven工程，引入依赖
 
  

    
        org.springframework
        spring-context
        5.3.13
    
    
        junit
        junit
        4.12
        test
    

 
  
创建POJO类、Dao类和接口
 
  
public class Student {
    private int id;
    private String name;
    private String address;
  // 省略getter/setter/构造方法/tostring
}
public interface StudentDao {
    // 根据id查询学生
    Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟从数据库查找出学生
        return new Student(1,"程序员","北京");
   }
}
 
  
编写xml配置文件，配置文件中配置需要Spring帮我们创建的对象。
 
  


         

 
  
 测试从Spring容器中获取对象。            
 
  
public class TestContainer {
    @Test
    public void t1(){
        // 创建Spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 从容器获取对象
        StudentDao studentDao1 = (StudentDao) ac.getBean("studentDao");
        StudentDao studentDao2 = (StudentDao) ac.getBean("studentDao");
        System.out.println(studentDao1.hashCode());
        System.out.println(studentDao2.hashCode());
        System.out.println(studentDao1.findById(1));
   }
}
 
  
 IOC_Spring容器类型                                                                     Spring-全面详解（学习总结---从入门到深化）_第7张图片容器接口                            
 
  
 
   
 1、BeanFactory：BeanFactory是Spring容器中的顶层接口，它可 以对Bean对象进行管理。
 
   
2、ApplicationContext：ApplicationContext是BeanFactory的子 接口。它除了继承 BeanFactory的所有功能外，还添加了对国际 化、资源访问、事件传播等方面的良好支持。
 
  
 
  
 ApplicationContext有以下三个常用实现类：、
 
  
容器实现类
 
  
 
   
1、ClassPathXmlApplicationContext：该类可以从项目中读取配置文件
 
   
2、FileSystemXmlApplicationContext：该类从磁盘中读取配置文件
 
   
3、AnnotationConfigApplicationContext：使用该类不读取配置文件，而是会读取注解
 
  
 
  
@Test
public void t2(){
    // 创建spring容器
    //       ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    ApplicationContext ac = new FileSystemXmlApplicationContext("C:\\Users\\a\\IdeaProjects\\spring_demo\\src\\main\\resources\\bean.xml");
    
    // 从容器中获取对象
    StudentDao userDao = (StudentDao)ac.getBean("studentDao");
    System.out.println(userDao);
    System.out.println(userDao.findById(1));
}
 
  
 IOC_对象的创建方式
 
  
Spring-全面详解（学习总结---从入门到深化）_第8张图片
 
  
 Spring会帮助我们创建bean，那么它底层是调用什么方法进行创建 的呢？
 
  
使用构造方法
 
  
Spring默认使用类的空参构造方法创建bean：
 
  
// 假如类没有空参构造方法，将无法完成bean的创建
public class StudentDaoImpl implements StudentDao{
    public StudentDaoImpl(int a){}    
    @Override
    public Student findById(int id) {
        // 模拟根据id查询学生
        return new Student(1,"程序员","北京");
   }
}
 
  
使用工厂类的方法
 
  
Spring可以调用工厂类的方法创建bean：
 
  
1、创建工厂类，工厂类提供创建对象的方法：
 
  
public class StudentDaoFactory {
    public StudentDao getStudentDao(){
        return new StudentDaoImpl(1);
   }
}

 
  
2 在配置文件中配置创建bean的方式为工厂方式。
 
  




 
  
3 测试
 
  
使用工厂类的静态方法
 
  
Spring可以调用工厂类的静态方法创建bean：
 
  
1 创建工厂类，工厂提供创建对象的静态方法。
 
  
public class StudentDaoFactory2 {
    public static StudentDao getStudentDao2() {
        return new StudentDaoImpl();
   }
}

 
  
2 在配置文件中配置创建bean的方式为工厂静态方法。
 
  


 
  
3 测试
 
  
IOC_对象的创建策略
 
  
Spring-全面详解（学习总结---从入门到深化）_第9张图片 Spring通过配置 中的 scope 属性设置对象的创建策略，共有五种创建策略
 
  
1、singleton：单例，默认策略。整个项目只会创建一个对象，通过中的 lazy-init 属性可以设置单例对象的创建时机：
 
  
 
   
 lazy-init="false"(默认)：立即创建，在容器启动时会创建配 置文件中的所有Bean对象。 lazy-init="true"：延迟创建，第一次使用Bean对象时才会创 建。
 
  
 
  
 配置单例策略：
 
  



 
  
测试单例策略：
 
  
// 为Bean对象的类添加构造方法
public StudentDaoImpl2(){
    System.out.println("创建 StudentDao！！！");
}
@Test
public void t2(){
    // 创建Spring容器
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean1.xml");
    // 从容器获取对象
    StudentDao studentDao1 = (StudentDao)ac.getBean("studentDao");
    StudentDao studentDao2 = (StudentDao)ac.getBean("studentDao");
    StudentDao studentDao3 = (StudentDao)ac.getBean("studentDao");
    System.out.println(studentDao1.hashCode());
    System.out.println(studentDao2.hashCode());
    System.out.println(studentDao3.hashCode());
}
 
  
2、prototype：多例，每次从容器中获取时都会创建对象。
 
  



 
  
3、request：每次请求创建一个对象，只在web环境有效。
 
  
4、session：每次会话创建一个对象，只在web环境有效。
 
  
5、gloabal-session：一次集群环境的会话创建一个对象，只在web 环境有效。
 
  
 IOC_对象的销毁时机
 
  
Spring-全面详解（学习总结---从入门到深化）_第10张图片
 
  
 对象的创建策略不同，销毁时机也不同：
 
  
 
   
singleton：对象随着容器的销毁而销毁。
 
   
prototype：使用JAVA垃圾回收机制销毁对象。
 
   
request：当处理请求结束，bean实例将被销毁。
 
   
session：当HTTP Session最终被废弃的时候，bean也会被销毁掉。
 
   
gloabal-session：集群环境下的session销毁，bean实例也将被销毁。
 
  
 
  
 IOC_生命周期方法
 
  
Spring-全面详解（学习总结---从入门到深化）_第11张图片
 
  
 Bean对象的生命周期包含创建——使用——销毁，Spring可以配置 Bean对象在创建和销毁时自动执行的方法：
 
  
1 定义生命周期方法
 
  
public class StudentDaoImpl2 implements StudentDao{
     // 创建时自动执行的方法
    public void init(){
        System.out.println("创建StudentDao！！！");
   }
    // 销毁时自动执行的方法
    public void destory(){
        System.out.println("销毁StudentDao！！！");
   }
}
 
  
2 配置生命周期方法
 
  


 
  
3 测试
 
  
@Test
public void t3(){
    // 创建Spring容器
    ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean1.xml");
    // 销毁Spring容器，ClassPathXmlApplicationContext才有销毁容器的方法
    ac.close();
}
 
  
IOC_获取Bean对象的方式
 
  
Spring-全面详解（学习总结---从入门到深化）_第12张图片
 
  
 Spring有多种获取容器中对象的方式：
 
  
通过id/name获取
 
  
配置文件
 
  



 
  
获取对象
 
  
StudentDao studentDao = (StudentDao) ac.getBean("studentDao");
 
  
通过类型获取
 
  
配置文件
 
  
 
  
获取对象
 
  
StudentDao studentDao2 = ac.getBean(StudentDao.class);

 
  
通过类型+id/name获取
 
  
虽然使用类型获取不需要强转，但如果在容器中有一个接口的多个 实现类对象，则获取时会报错，此时需要使用类型+id/name获取
 
  
配置文件
 
  


 
  
获取对象
 
  
StudentDao studentDao2 = ac.getBean("studentDao",StudentDao.class);
 
  
DI_什么是依赖注入
 
  
Spring-全面详解（学习总结---从入门到深化）_第13张图片
 
  
 依赖注入（Dependency Injection，简称DI），它是Spring控制反 转思想的具体实现。 控制反转将对象的创建交给了Spring，但是对象中可能会依赖其他 对象。比如service类中要有dao类的属性，我们称service依赖于 dao。之前需要手动注入属性值，代码如下：
 
  
public interface StudentDao {
    Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟根据id查询学生
        return new Student(1,"程序员","北京");
   }
}
public class StudentService {
  // service依赖dao，手动注入属性值，即手动维护依赖关系
    private StudentDao studentDao = new StudentDaoImpl();
    public Student findStudentById(int id){
        return studentDao.findById(id);
   }
}

 
  
此时，当StudentService的想要使用StudentDao的另一个实现类如 StudentDaoImpl2时，则需要修改Java源码，造成代码的可维护性 降低。 而使用Spring框架后，Spring管理Service对象与Dao对象，此时它 能够为Service对象注入依赖的Dao属性值。这就是Spring的依赖注 入。简单来说，控制反转是创建对象，依赖注入是为对象的属性赋 值。
 
  
DI_依赖注入方式
 
  
Spring-全面详解（学习总结---从入门到深化）_第14张图片
 
  
 在之前开发中，可以通过setter方法或构造方法设置对象属性值：
 
  
// setter方法设置属性
StudentService studentService = new StudentService();
StudentDao studentDao = new StudentDao();
studentService.setStudentDao(studentDao);
// 构造方法设置属性
StudentDao studentDao = new StudentDao();
StudentService studentService = new StudentService(studentDao);
 
  
Spring可以通过调用setter方法或构造方法给属性赋值
 
  
Setter注入
 
  
被注入类编写属性的setter方法
 
  
public class StudentService {
    private StudentDao studentDao;
    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
   }
}

 
  
配置文件中，给需要注入属性值的 中设置
 
  


    
    
    

 
  
测试是否注入成功
 
  
@Test
public void t2(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    StudentService studentService = (StudentService) ac.getBean("studentService");
    System.out.println(studentService.findStudentById(1));
}
 
  
构造方法注入
 
  
被注入类编写有参的构造方法
 
  
public class StudentService {
    private StudentDao studentDao;
    public StudentService(StudentDao studentDao) {
        this.studentDao = studentDao;
   }
}
 
  
给需要注入属性值的 中设置
 
  


    
    
    


 
  
测试是否注入成功
 
  
@Test
public void t2(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    StudentService studentService =(StudentService) ac.getBean("studentService");
  System.out.println(studentService.findStudentById(1));
}
 
  
自动注入
 
  
Spring-全面详解（学习总结---从入门到深化）_第15张图片
 
  
 
   
 自动注入不需要在 标签中添加其他标签注入属性值，而是自 动从容器中找到相应的bean对象设置为属性值。
 
  
 
  
 Spring-全面详解（学习总结---从入门到深化）_第16张图片
 
  
 测试自动注入：
 
  
    1、为依赖的对象提供setter和构造方法：
 
  
public class StudentService {
     // 依赖
     private StudentDao studentDao;
     // 构造方法
     public StudentService() { }
    
    public StudentService(StudentDao studentDao) {
        this.studentDao = studentDao;
   }
    // setter方法
    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
   }
    // 调用依赖的方法
    public Student findStudentById(int id)
      {
        return studentDao.findById(id);
      }
}
 
  
2、配置自动注入：
 
  



 
  



 
  



 
  


 
  
DI_依赖注入类型
 
  
Spring-全面详解（学习总结---从入门到深化）_第17张图片
 
  
 DI支持注入bean类型、基本数据类型和字符串、List集合、Set集合、Map集合、Properties对象类型等，他们的写法如下：
 
  
1、准备注入属性的类
 
  
public class StudentService {
    private StudentDao studentDao; // bean属性

    private String name; //字符串类型

    private int count; //基本数据类型

    private List names; // 字符串类型List集合

    private List students1; // 对象类型List集合

    private Set students2; // 对象类型Set集合

    private Map names2; //字符串类型Map集合

    private Map students3;// 对象类型Map集合

    private Properties properties;//Properties类型

    // 省略getter/setter/toString
}
 
  
2、准备测试方法
 
  
@Test
public void t3(){
    ApplicationContext ac = newClassPathXmlApplicationContext("bean.xml");
    StudentService studentService =(StudentService)ac.getBean("studentService");
    System.out.println(studentService);
}

 
  
注入bean类型
 
  
写法一：
 
  


    

 
  
写法二：
 
  


    
        
    

 
  
注入基本数据类型
 
  

    
    

    
    
        10
    

 
  
注入List集合
 
  

    
    
        
            强学堂
            程序员
        
    
    
    
        
            
                
                
                
            
            
                
                
                
            
        
    

 
  
注入Set集合
 
  

    
    
        
            
                
                
                
            
            
                
                
                
            
        
    

 
  
注入Map集合
 
  
简单数据类型Map集合：
 
  

    
        
            
            
        
    

 
  
对象类型Map集合：
 
  

    
        
            
            
        
    


    
    
    


    
    
    

 
  
注入Properties对象
 
  

    
        
            值1
            值2
        
    

 
  
注解实现IOC_准备工作
 
  
注解配置和xml配置对于Spring的IOC要实现的功能都是一样的，只是配置的形式不一样。
 
  
准备工作
 
  
 
   
1 创建一个新的Spring项目。
 
   
2 编写pojo，dao，service类。
 
   
3 编写空的配置文件，如果想让该文件支持注解，需要添加新的约束：
 
  
 
  
 
  



 
  
注解实现IOC_@Component
 
  
Spring-全面详解（学习总结---从入门到深化）_第18张图片
 
  
 
   
 作用：用于创建对象，放入Spring容器，相当于
 
   
 位置：类上方
 
   
 注意：
 
   
     1、要在配置文件中配置扫描的包，扫描到该注解才能生效。
 
   
 
   
   2、@Component 注解配置bean的默认id是首字母小写的类名。也 可以手动设置bean的id值。
 
   
// 此时bean的id为studentDaoImpl
@Component
public class StudentDaoImpl implements StudentDao{
    public Student findById(int id) {
        // 模拟根据id查询学生
        return new Student(1,"程序员","北京");
   }
}
// 此时bean的id为studentDao
@Component("studentDao")
public class StudentDaoImpl implements StudentDao{
    public Student findById(int id) {
        // 模拟根据id查询学生
        return new Student(1,"程序员","北京");
   }
}
 
  
 
  
 注解实现IOC_@Repository、@Service、@Controller
 
  
Spring-全面详解（学习总结---从入门到深化）_第19张图片
 
  
 作用：这三个注解和@Component的作用一样，使用它们是为了区 分该类属于什么层。
 
  
 
   
位置：
 
   
1、@Repository用于Dao层
 
   
2、@Service用于Service层
 
   
3、@Controller用于Controller层
 
  
 
  
@Repository
public class StudentDaoImpl implements StudentDao{}
@Service
public class StudentService {}
 
  
注解实现IOC_@Scope
 
  
Spring-全面详解（学习总结---从入门到深化）_第20张图片
 
  
 
   
 作用：指定bean的创建策略
 
   
位置：类上方
 
   
取值：singleton prototype request session globalsession
 
   
@Service
@Scope("singleton")
public class StudentService {}
 
  
 
  
注解实现IOC_@Autowired 
 
  
Spring-全面详解（学习总结---从入门到深化）_第21张图片
 
  
 
   
作用：从容器中查找符合属性类型的对象自动注入属性中。用于代替 中的依赖注入配置。
 
   
位置：属性上方、setter方法上方、构造方法上方。
 
   
注意：  
 
   
       1、@Autowired 写在属性上方进行依赖注入时，可以省略setter方法。
 
   
       
 
   
@Component
public class StudentService {
    @Autowired
    private StudentDao studentDao;
    public Student findStudentById(int id)
     {
        return studentDao.findById(id);
     }
}
@Test
public void t2(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    StudentService studentService =(StudentService)ac.getBean("studentService");
  System.out.println(studentService.findStudentById(1));
}
 
   
      2、容器中没有对应类型的对象会报错
 
   
// 如果StudentDaoImpl没有放到容器中会报错
//@Component("studentDao")
public class StudentDaoImpl implements StudentDao{
    public Student findById(int id) {
        // 模拟根据id查询学生
        return new Student(1,"程序员","北京");
   }
}
 
   
3 、容器中有多个对象匹配类型时，会找beanId等于属性名的对 象，找不到会报错。
 
   
// 如果容器中都多个同类型对象，会根据id值等于属性
名找对象
@Component("studentDao")
public class StudentDaoImpl implements StudentDao{
    public Student findById(int id) {
        // 模拟根据id查询学生
        return new Student(1,"程序员","北京");
   }
}
@Component
public class StudentDaoImpl implements StudentDao{
    public Student findById(int id) {
        // 模拟根据id查询学生
        return new Student(1,"程序员","北京");
 }
}
 
  
 
  
注解实现IOC_@Qualifier 
 
  
 Spring-全面详解（学习总结---从入门到深化）_第22张图片
 
  
 
   
 作用：在按照类型注入对象的基础上，再按照bean的id注入。
 
   
位置：属性上方
 
   
注意：@Qualifier必须和@Autowired一起使用。
 
  
 
  
@Component
public class StudentService {
    @Autowired
    @Qualifier("studentDaoImpl2")
    private StudentDao studentDao;
    public Student findStudentById(int id){
        return studentDao.findById(id);
   }
}
 
  
注解实现IOC_@Value
 
  
Spring-全面详解（学习总结---从入门到深化）_第23张图片
 
  
 
   
 作用：注入String类型和基本数据类型的属性值。
 
   
位置：属性上方
 
   
用法：
 
   
        1 、直接设置固定的属性值
 
   
@Service
public class StudentService {
    @Value("1")
    private int count;
    @Value("hello")
    private String str;
}
 
   
        2 、获取配置文件中的属性值：
 
   
                 2.1 、编写配置文件db.properties
 
   
                  
 
   
jdbc.username=root
jdbc.password01=123456
 
   
                 2.2、spring核心配置文件扫描配置文件
 
   
                 
 
   


 
   
                2.3 注入配置文件中的属性值
 
   
@Value("${jdbc.username}")
private String username;
@Value("${jdbc.password}")
private String password;
 
  
 
  
注解实现IOC_@Configuration 
 
  
Spring-全面详解（学习总结---从入门到深化）_第24张图片
 
  
 此时基于注解的IOC配置已经完成，但是我们依然离不开Spring的 xml配置文件。接下来我们脱离bean.xml，使用纯注解实现IOC。
 
  
 
   
在真实开发中，我们一般还是会保留xml配置文件，很多情况下使用配置文件更加方便。
 
  
 
  
 纯注解实现IOC需要一个Java类代替xml文件。这个Java类上方需要 添加@Configuration，表示该类是一个配置类，作用是代替配置文件。
 
  
@Configuration
public class SpringConfig {  
}
 
  
注解实现IOC_@ComponentScan
 
  
 
   
作用：指定spring在初始化容器时扫描的包。
 
   
位置：配置类上方
 
   
@Configuration
@ComponentScan("com.itbaizhan")
    public class SpringConfig { }

 
  
 
  
 注解实现IOC_@PropertySource
 
  
Spring-全面详解（学习总结---从入门到深化）_第25张图片
 
  
 
   
 作用：代替配置文件中的 扫描配置文件
 
   
位置：配置类上方
 
   
注意：配置文件位置前要加关键字 classpath
 
  
 
  
@Configuration
@PropertySource("classpath:db.properties")
public class JdbcConfig {
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
}
 
  
注解实现IOC_@Bean
 
  
Spring-全面详解（学习总结---从入门到深化）_第26张图片
 
  
 
   
作用：将方法的返回值对象放入Spring容器中。如果想将第三方类 的对象放入容器，可以使用@Bean
 
   
位置：配置类的方法上方。
 
   
属性：name：给bean对象设置id
 
   
注意：@Bean修饰的方法如果有参数，spring会根据参数类型从容 器中查找可用对象。
 
   
举例：如果想将jdbc连接对象放入Spring容器，我们无法修改 Connection源码添加@Component，此时就需要使用将@Bean该 对象放入Spring容器
 
   
 1 、添加驱动依赖
 
   
    
 
   

    mysql
    mysql-connector-java
    8.0.27

 
   
2、将Connection对象放入Spring容器
 
   
@Bean(name = "connection")
public Connection getConnection(){
    try {
      Class.forName("com.mysql.cj.jdbc.Driver");
        returnDriverManager.getConnection("jdbc:mysql:///mysql", "root", "root");
   } catch (Exception exception) {
        return null;
   }
}
 
   
3、测试
 
   
@Test
public void t5(){
    ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfig.class);
    Connection connection = (Connection)ac.getBean("connection");
    System.out.println(connection);
}
 
  
 
  
注解实现IOC_@Import 
 
  
Spring-全面详解（学习总结---从入门到深化）_第27张图片
 
  
 
   
 作用：如果配置过多，会有多个配置类，该注解可以为主配置类导入其他配置类
 
   
 位置：主配置类上方
 
  
 
  
// Jdbc配置类
@Configuration
public class JdbcConfig {
    @Bean(name = "connection")
    public Connection getConnection(){
        try {
          Class.forName("com.mysql.cj.jdbc.Driver");
          return DriverManager.getConnection("jdbc:mysql:///mysql", "root", "root");
       } catch (Exception exception) {
            return null;
       }
   }
}
// 主配置类
@Configuration
@ComponentScan("com.itbaizhan")
@Import(JdbcConfig.class)
public class SpringConfig { }
 
  
Spring整合MyBatis_搭建环境
 
  
Spring-全面详解（学习总结---从入门到深化）_第28张图片
 
  
 我们知道使用MyBatis时需要写大量创建 SqlSessionFactoryBuilder、SqlSessionFactory、SqlSession等对 象的代码，而Spring的作用是帮助我们创建和管理对象，所以我们 可以使用Spring整合MyBatis，简化MyBatis开发。
 
  
创建maven项目，引入依赖。
 
  

    
    
        org.mybatis
        mybatis
        3.5.7
    

    
    
        mysql
        mysql-connector-java
        8.0.26
    

    
    
      org.springframework
        spring-context
        5.3.13
    
    
      org.springframework
        spring-tx
        5.3.13
    
    
      org.springframework
        spring-jdbc
        5.3.13
    

    
    
        org.mybatis
        mybatis-spring
        2.0.6
    


 
  
Spring整合MyBatis_编写配置文件
 
  
 1、编写数据库配置文件db.properties
 
  
jdbc.driverClassName = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql:///student
jdbc.username = root
jdbc.password01 = root
 
  
2、创建MyBatis配置文件SqlMapConfig.xml，数据源、扫描接口都 交由Spring管理，不需要在MyBatis配置文件中设置。
 
  




 
  
3、创建Spring配置文件applicationContext.xml
 
  


    
    
    
    
    
    
        
        
        
        
    
    
    
        
    
    
    
        
    

 
  
 Spring整合MyBatis_准备数据库和实体类
 
  
准备数据库
 
  
CREATE DATABASE `student`;
USE `student`;
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `sex` varchar(10) DEFAULT NULL,
  `address` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT
CHARSET=utf8;
insert  into
`student`(`id`,`name`,`sex`,`address`)
values (1,'程序员','男','北京'),(2,'北京学堂','女','北京');

 
  
准备实体类
 
  
public class Student {
    private int id;
    private String name;
    private String sex;
    private String address;
    
    // 省略构造方法/getter/setter/tostring
}
 
  
Spring整合MyBatis_编写持久层接口和service类
 
  
编写持久层接口
 
  
@Repository
public interface StudentDao {
    // 查询所有学生
    @Select("select * from student")
    List findAll();
    // 添加学生
    @Insert("insert into student values(null,#{name},#{sex},#{address})")
    void add(Student student);
}
 
  
编写service类
 
  
@Service
public class StudentService {
    // SqlSession对象
    @Autowired
    private SqlSessionTemplate sqlSession;
    // 使用SqlSession获取代理对象
    public List findAllStudent(){
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        return studentDao.findAll();
   }
}
 
  
Spring整合MyBatis_Spring整合Junit进行单元测试
 
  
之前进行单元测试时都需要手动创建Spring容器，能否在测试时让 Spring自动创建容器呢？
 
  
1 、引入Junit和Spring整合Junit依赖
 
  


    junit
    junit
    4.12
    test



    org.springframework
    spring-test
    5.3.13

 
  
2 、编写测试类
 
  
// JUnit使用Spring方式运行代码，即自动创建spring容器。
@RunWith(SpringJUnit4ClassRunner.class)
// 告知创建spring容器时读取哪个配置类或配置文件
// 配置类写法：
@ContextConfiguration(classes=配置类.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class StudentServiceTest {
    @Autowired
    private StudentService studentService;
    
    @Test
    public void testFindAll(){
        List allStudent = studentService.findAllStudent();
        allStudent.forEach(System.out::println);
   }
}
 
  
 
   
注：使用SqlSessionTemplate创建代理对象还是需要注册接口 或者映射文件的。
 
   
1、在MyBatis配置文件注册接口
 
   

    
        
    

 
   
2、创建sqlSessionFactory时指定MyBatis配置文件
 
   


    
    


 
  
 
  
Spring整合MyBatis_自动创建代理对象 
 
  
Spring提供了MapperScannerConfigurer对象，该对象可以自动扫 描包创建代理对象，并将代理对象放入容器中，此时不需要使用 SqlSession手动创建代理对象。
 
  
 
   
1、创建MapperScannerConfigurer对象
 
   


    
    

 
   
2、Service类直接使用代理对象即可
 
   
@Service
public class StudentService {
    // 直接注入代理对象
    @Autowired
    private StudentDao studentDao;
  
    // 直接使用代理对象
    public void addStudent(Student student){
        studentDao.add(student);
   }
}
 
   
3、测试
 
   
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath :applicationContext.xml")
public class StudentServiceTest {
    @Autowired
    private StudentService studentService;
    
    @Test
    public void testAdd(){
        Student student = new Student(0, "百战不败", "男", "上海");
        studentService.addStudent(student);
   }
}
 
  
 
  
SpringAOP_AOP简介 
 
  
Spring-全面详解（学习总结---从入门到深化）_第29张图片
 
  
 AOP的全称是Aspect Oriented Programming，即面向切面编程。 是实现功能统一维护的一种技术，它将业务逻辑的各个部分进行隔 离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高 了开发效率。
 
  
 
   
作用：在不修改源码的基础上，对已有方法进行增强。
 
   
实现原理：动态代理技术。
 
   
优势：减少重复代码、提高开发效率、维护方便
 
   
应用场景：事务处理、日志管理、权限控制、异常处理等方面。
 
  
 
  
 SpringAOP_AOP相关术语
 
  
Spring-全面详解（学习总结---从入门到深化）_第30张图片
 
  
 为了更好地理解AOP，就需要对AOP的相关术语有一些了解
 
  
Spring-全面详解（学习总结---从入门到深化）_第31张图片
 
  
 SpringAOP_AOP入门
 
  
 
   
AspectJ是一个基于Java语言的AOP框架，在Spring框架中建议使用 AspectJ实现AOP。
 
   
接下来我们写一个AOP入门案例：dao层的每个方法结束后都可以 打印一条日志：
 
   
1、引入依赖
 
   


    org.springframework
    spring-context
    5.3.13




    org.aspectj
    aspectjweaver
    1.8.7




    junit
    junit
    4.12
    test

 
   
2、编写连接点
 
   
@Repository
public class UserDao {
    public void add(){
        System.out.println("用户新增");
   }
    public void delete(){
        System.out.println("用户删除");
   }
    public void update(){
        System.out.println("用户修改");
   }
}
 
   
3、编写通知类
 
   
public class MyAspectJAdvice {
    // 后置通知
    public void myAfterReturning() {
        System.out.println("打印日志...");
   }
}
 
   
4、配置切面
 
   


    
    
    
    
    
    
        
            
            
            
            
        
    

 
   
5、测试
 
   
public class UserDaoTest {
    @Test
    public void testAdd(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        UserDao userDao = (UserDao) ac.getBean("userDao");
        userDao.add();
   }
    @Test
    public void testDelete(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        UserDao userDao = (UserDao)ac.getBean("userDao");
        userDao.delete();
   }
    @Test
    public void testUpdate(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        UserDao userDao = (UserDao) ac.getBean("userDao");
        userDao.update();
   }
}
 
  
 
  
 SpringAOP_通知类型
 
  
Spring-全面详解（学习总结---从入门到深化）_第32张图片
 
  
 AOP有以下几种常用的通知类型：
 
  
Spring-全面详解（学习总结---从入门到深化）_第33张图片
 
  
 
   
 1、编写通知方法
 
   
// 通知类
public class MyAspectAdvice {
    // 后置通知
    public void myAfterReturning(JoinPoint joinPoint) {
        System.out.println("切点方法名：" + joinPoint.getSignature().getName());
        System.out.println("目标对象：" + joinPoint.getTarget());
        System.out.println("打印日志" + joinPoint.getSignature().getName() + "方法被执行了！");
   }
    // 前置通知
    public void myBefore() {
        System.out.println("前置通知...");
   }
    // 异常通知
    public void myAfterThrowing(Exception ex) {
        System.out.println("异常通知...");
        System.err.println(ex.getMessage());
   }
    // 最终通知
    public void myAfter() {
        System.out.println("最终通知");
   }
    // 环绕通知
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕前");
        Object obj = proceedingJoinPoint.proceed(); // 执行方法
        System.out.println("环绕后");
        return obj;
   }
}
 
   
2、配置切面
 
   


    
    
        
        
        
        
        
        
        
        
        
        
        
        
    

 
  
 
  
SpringAOP_切点表达式 
 
  
Spring-全面详解（学习总结---从入门到深化）_第34张图片
 
  
 
   
使用AspectJ需要使用切点表达式配置切点位置，写法如下：
 
   
1、标准写法：访问修饰符 返回值 包名.类名.方法名(参数列表)
 
   
2、访问修饰符可以省略。
 
   
3、返回值使用 * 代表任意类型。
 
   
4、包名使用 * 表示任意包，多级包结构要写多个 * ，使用 *.. 表示任 意包结构
 
   
5、类名和方法名都可以用 * 实现通配。
 
   
6、参数列表
 
   
基本数据类型直接写类型
引用类型写 包名.类名
* 表示匹配一个任意类型参数
.. 表示匹配任意类型任意个数的参数
 
   
7、全通配： * *..*.*(..)
 
  
 
  
SpringAOP_多切面配置 
 
  
Spring-全面详解（学习总结---从入门到深化）_第35张图片
 
  
 我们可以为切点配置多个通知，形成多切面，比如希望dao层的每 个方法结束后都可以打印日志并发送邮件：
 
  
 
   
1、编写发送邮件的通知：
 
   
public class MyAspectJAdvice2 {
    // 后置通知
    public void myAfterReturning(JoinPoint joinPoint) {
        System.out.println("发送邮件");
   }
}
 
   
2、配置切面：
 
   





    
    
        
        
        
        
    
    
    
        
        
    


 
  
 
  
 SpringAOP_注解配置AOP
 
  
Spring可以使用注解代替配置文件配置切面：
 
  
 
   
1、在xml中开启AOP注解支持
 
   



 
   
2、在通知类上方加入注解 @Aspect 
 
   
3、在通知方法上方加入注解
 
   
@Before/@AfterReturning/@AfterThrowing/@After/@Around

 
   
@Aspect
@Component
public class MyAspectAdvice {
    // 后置通知
    @AfterReturning("execution(* com.itbaizhan.dao.UserDao.*(..))")
    public void myAfterReturning(JoinPoint joinPoint) {
        System.out.println("切点方法名：" + joinPoint.getSignature().getName());
        System.out.println("目标对象：" + joinPoint.getTarget());
        System.out.println("打印日志" + joinPoint.getSignature().getName() + "方法被执行了！");
   }
    // 前置通知
    @Before("execution(* com.itbaizhan.dao.UserDao.*(..))")
    public void myBefore() {
        System.out.println("前置通知...");
   }
    // 异常通知
    @AfterThrowing(value = "execution(* com.itbaizhan.dao.UserDao.*(..))",throwing = "ex")
    public void myAfterThrowing(Exception ex) {
        System.out.println("异常通知...");
        System.err.println(ex.getMessage());
   }
    // 最终通知
    @After("execution(* com.itbaizhan.dao.UserDao.*(..))")
    public void myAfter() {
        System.out.println("最终通知");
   }
    // 环绕通知
    @Around("execution(* com.itbaizhan.dao.UserDao.*(..))")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕前");
        Object obj = proceedingJoinPoint.proceed(); // 执行方法
        System.out.println("环绕后");
        return obj;
   }
}
 
  
 
  
 
   
 4、测试：
 
   
@Test
public void testAdd2(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean1.xml");
    UserDao userDao = (UserDao) ac.getBean("userDao");
    userDao.update();
}
 
  
 
  
 
   
如何为一个类下的所有方法统一配置切点：
 
   
1、在通知类中添加方法配置切点
 
   
@Pointcut("execution(* com.itbaizhan.dao.UserDao.*(..))")
public void pointCut(){}
 
   
2、在通知方法上使用定义好的切点
 
   
@Before("pointCut()")
public void myBefore(JoinPoint joinPoint) {
    System.out.println("前置通知...");
}
@AfterReturning("pointCut()")
public void myAfterReturning(JoinPoint joinPoint) {
    System.out.println("后置通知...");
}
 
   
配置类如何代替xml中AOP注解支持？
 
   
在配置类上方添加@EnableAspectJAutoProxy即可
 
   
@Configuration
@ComponentScan("com.itbaizhan")
@EnableAspectJAutoProxy
public class SpringConfig {
}

 
  
 
  
 
  
SpringAOP_原生Spring实现AOP
 
  
Spring-全面详解（学习总结---从入门到深化）_第36张图片
 
  
 除了AspectJ，Spring支持原生方式实现AOP。
 
  
 
   
1、引入依赖
 
   


    org.springframework
    spring-aop
    5.3.13

 
   
2、编写通知类
 
   
// Spring原生Aop的通知类
public class SpringAop implements MethodBeforeAdvice, AfterReturningAdvice,
ThrowsAdvice, MethodInterceptor {
    /**
     * 前置通知
     * @param method 目标方法
     * @param args 目标方法的参数列表
     * @param target 目标对象
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("前置通知");
     }
    /**
     * 后置通知
     * @param returnValue 目标方法的返回值
     * @param method 目标方法
     * @param args 目标方法的参数列表
     * @param target 目标对象
     * @throws Throwable
     */
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("后置通知");
   }
    /**
     * 环绕通知
     * @param invocation 目标方法
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("环绕前");
        Object proceed = invocation.proceed();
        System.out.println("环绕后");
        return proceed;
   }
    /**
     * 异常通知
     * @param ex 异常对象
     */
    public void afterThrowing(Exception ex){
        System.out.println("发生异常了！");
    }
}
 
   
Spring原生方式实现AOP时，只支持四种通知类型：
 
   
Spring-全面详解（学习总结---从入门到深化）_第37张图片
 
   
 
 
   
3、编写配置类
 
   




    
    
    
    
        
            springAop
        
    
    
    

 
   
4、编写测试类
 
   
public class UserDaoTest2 {
    @Test
    public void testAdd(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean2.xml");
        UserDao userDao = (UserDao) ac.getBean("userDaoProxy"); // 获取的是代理对象
        userDao.update();
   }
}
 
  
 
  
SpringAOP_SchemaBased实现AOP 
 
  
SchemaBased(基础模式)配置方式是指使用Spring原生方式定义通 知，而使用AspectJ框架配置切面。
 
  
 
   
1、编写通知类
 
   
public class SpringAop implements MethodBeforeAdvice, AfterReturningAdvice,ThrowsAdvice, MethodInterceptor {
    /**
     * 前置通知
     * @param method 目标方法
     * @param args 目标方法的参数列表
     * @param target 目标对象
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("前置通知");
     }
    /**
     * 后置通知
     * @param returnValue 目标方法的返回值
     * @param method 目标方法
     * @param args 目标方法的参数列表
     * @param target 目标对象
     * @throws Throwable
     */
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("后置通知");
   }
    /**
     * 环绕通知
     * @param invocation 目标方法
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("环绕前");
        Object proceed = invocation.proceed();
        System.out.println("环绕后");
        return proceed;
   }
    /**
     * 异常通知
     * @param ex 异常对象
     */
    public void afterThrowing(Exception ex){
        System.out.println("发生异常了！");
   }
}
 
   
2、配置切面
 
   




    
    
    
    

 
   
3、测试
 
   
@Test
public void t6(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("aop3.xml");
    UserDao userDao = (UserDao) ac.getBean("userDao");
    userDao.add();
}
 
  
 
  
Spring事务_事务简介
 
  
 Spring-全面详解（学习总结---从入门到深化）_第38张图片
 
  
 事务：不可分割的原子操作。即一系列的操作要么同时成功，要么同时失败。
 
  
开发过程中，事务管理一般在service层，service层中可能会操作多次数据库，这些操作是不可分割的。否则当程序报错时，可能会造 成数据异常。
 
  
如：张三给李四转账时，需要两次操作数据库：张三存款减少、李四存款增加。如果这两次数据库操作间出现异常，则会造成数据错 误。
 
  
 
   
1、准备数据库
 
   
CREATE DATABASE `spring` ;
USE `spring`;
DROP TABLE IF EXISTS `account`;
CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) DEFAULT NULL,
  `balance` double DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT
CHARSET=utf8;
insert  into `account`(`id`,`username`,`balance`) values (1,'张三',1000),(2,'李四',1000);
 
   
2、创建maven项目，引入依赖
 
   

    
    
        org.mybatis
        mybatis
        3.5.7
    
   
    
        mysql
        mysql-connectorjava
        8.0.26
    
    
    
        com.alibaba
        druid
        1.2.8
    
    
    
        org.springframework
        springcontext
        5.3.13
    
    
        org.springframework
        spring-tx
        5.3.13
    
    
        org.springframework
        springjdbc
        5.3.13
    
    
    
        org.mybatis
        mybatisspring
        2.0.6
    
    
    
        junit
        junit
        4.12
        test
    
    
    
        org.springframework
        springtest
        5.3.13
        test
    

 
   
3、创建配置文件
 
   


    
    
    
    
        
        
        
        
    
    
        
    
    
        
    

 
   
4、编写Java代码
 
   
// 账户
public class Account {
    private int id; // 账号
    private String username; // 用户名
    private double balance; // 余额
    
    // 省略getter/setter/tostring/构造方法
}

@Repository
public interface AccountDao {
    // 根据id查找用户
    @Select("select * from account where id = #{id}")
    Account findById(int id);
    // 修改用户
    @Update("update account set balance = #{balance} where id = #{id}")
    void update(Account account);
}

@Service
public class AccountService {
    @Autowired
    private AccountDao accountDao;
    /**
     * 转账
     * @param id1 转出人id
     * @param id2 转入人id
     * @param price 金额
     */
    public void transfer(int id1, int id2, double price) {
        // 转出人减少余额
        Account account1 = accountDao.findById(id1);
        account1.setBalance(account1.getBalance()-price);
        accountDao.update(account1);
        int i = 1/0; // 模拟程序出错
        // 转入人增加余额
        Account account2 = accountDao.findById(id2);
        account2.setBalance(account2.getBalance()+price);
        accountDao.update(account2);
   }
}
 
   
5、测试转账
 
   
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath :applicationContext.xml")
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;
    @Test
    public void testTransfer(){
        accountService.transfer(1,2,500);
   }
}
 
   
此时没有事务管理，会造成张三的余额减少，而李四的余额并没有 增加。所以事务处理位于业务层，即一个service方法是不能分割的。
 
  
 
  
Spring事务_Spring事务管理方案 
 
  
 
  
 在service层手动添加事务可以解决该问题：
 
  
@Autowired
private SqlSessionTemplate sqlSession;
public void transfer(int id1, int id2,double price) {
    try{
        // account1修改余额
        Account account1 = accountDao.findById(id1);
        account1.setBalance(account1.getBalance()- price);
        accountDao.update(account1);
        int i = 1/0; // 模拟转账出错
        // account2修改余额
        Account account2 = accountDao.findById(id2);
        account2.setBalance(account2.getBalance()+price);
        accountDao.update(account2);  
        sqlSession.commit();
     }catch(Exception ex){
        sqlSession.rollback();
   }
}
 
  
但在Spring管理下不允许手动提交和回滚事务。此时我们需要使用 Spring的事务管理方案，在Spring框架中提供了两种事务管理方案：
 
  
 
   
1 编程式事务：通过编写代码实现事务管理。
 
   
2 声明式事务：基于AOP技术实现事务管理。
 
  
 
  
 
   
在Spring框架中，编程式事务管理很少使用，我们对声明式事务管 理进行详细学习。 Spring的声明式事务管理在底层采用了AOP技术，其最大的优点在 于无需通过编程的方式管理事务，只需要在配置文件中进行相关的 规则声明，就可以将事务规则应用到业务逻辑中。 
 
  
 
  
 使用AOP技术为service方法添加如下通知：
 
  
Spring-全面详解（学习总结---从入门到深化）_第39张图片
 
  
 Spring事务_Spring事务管理器
 
  
Spring-全面详解（学习总结---从入门到深化）_第40张图片
 
  
 
   
 Spring依赖事务管理器进行事务管理，事务管理器即一个通知类， 我们为该通知类设置切点为service层方法即可完成事务自动管理。 由于不同技术操作数据库，进行事务操作的方法不同。如：JDBC提 交事务是 connection.commit() ，MyBatis提交事务是 sqlSession.commit() ，所以 Spring提供了多个事务管理器。
 
  
 
  
Spring-全面详解（学习总结---从入门到深化）_第41张图片
 
  
 
   
 我们使用MyBatis操作数据库，接下来使用 DataSourceTransactionManager 进行事务管理。
 
  
 
  
 
   
 1、引入依赖
 
   


    org.springframework
    spring-tx
    5.3.13



    org.aspectj
    aspectjweaver
    1.8.7

 
   
2、在配置文件中引入约束
 
   
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
 
   
3、进行事务配置
 
   


    



    
        
    



    
    
    
    

 
  
 
  
Spring事务_事务控制的API
 
  
Spring-全面详解（学习总结---从入门到深化）_第42张图片
 
  
 Spring进行事务控制的功能是由三个接口提供的，这三个接口是 Spring实现的，在开发中我们很少使用到，只需要了解他们的作用 即可：
 
  
PlatformTransactionManager接口
 
  
 
   
PlatformTransactionManager是Spring提供的事务管理器接口，所 有事务管理器都实现了该接口。该接口中提供了三个事务操作方法：
 
   
1、TransactionStatus getTransaction（TransactionDefinition definition）：获取事务状态信息。
 
   
2、void commit（TransactionStatus status）：事务提交
 
   
3、void rollback（TransactionStatus status）：事务回滚
 
  
 
  
 TransactionDefinition接口
 
  
TransactionDefinition是事务的定义信息对象，它有如下方法：
 
  
 
   
String getName()：获取事务对象名称。
 
   
int getIsolationLevel()：获取事务的隔离级别。
 
   
int getPropagationBehavior()：获取事务的传播行为。
 
   
int getTimeout()：获取事务的超时时间。
 
   
boolean isReadOnly()：获取事务是否只读。
 
  
 
  
TransactionStatus接口 
 
  
TransactionStatus是事务的状态接口，它描述了某一时间点上事务 的状态信息。它有如下方法：
 
  
 
   
void flush() 刷新事务
 
   
boolean hasSavepoint() 获取是否存在保存点
 
   
boolean isCompleted() 获取事务是否完成
 
   
boolean isNewTransaction() 获取是否是新事务
 
   
boolean isRollbackOnly() 获取是否回滚
 
   
void setRollbackOnly() 设置事务回滚
 
  
 
  
Spring事务_事务的相关配置 
 
  
在 中可以进行事务的相关配置：
 
  

    
        
        
    

 
  
Spring-全面详解（学习总结---从入门到深化）_第43张图片
 
  
 Spring事务_事务的传播行为
 
  
Spring-全面详解（学习总结---从入门到深化）_第44张图片
 
  
 
   
 事务传播行为是指多个含有事务的方法相互调用时，事务如何在这 些方法间传播。 如果在service层的方法中调用了其他的service方法，假设每次执行 service方法都要开启事务，此时就无法保证外层方法和内层方法处 于同一个事务当中。
 
   
// method1的所有方法在同一个事务中
public void method1(){
    // 此时会开启一个新事务，这就无法保证method1()中所有的代码是在同一个事务中
    method2();
    System.out.println("method1");
}
public void method2(){
    System.out.println("method2");
}
 
   
事务的传播特性就是解决这个问题的，Spring帮助我们将外层方法 和内层方法放入同一事务中。
 
   
Spring-全面详解（学习总结---从入门到深化）_第45张图片
 
   
 
 
  
 
  
Spring事务_事务的隔离级别 
 
  
Spring-全面详解（学习总结---从入门到深化）_第46张图片
 
  
 事务隔离级别反映事务提交并发访问时的处理态度，隔离级别越 高，数据出问题的可能性越低，但效率也会越低。
 
  
Spring-全面详解（学习总结---从入门到深化）_第47张图片
 
  
Spring-全面详解（学习总结---从入门到深化）_第48张图片
 
  
 Spring事务_注解配置声明式事务
 
  
 
   
Spring支持使用注解配置声明式事务。用法如下：
 
   
1、注册事务注解驱动
 
   


 
   
2、在需要事务支持的方法或类上加@Transactional
 
   
 @Service
// 作用于类上时，该类的所有public方法将都具有该类型的事务属性
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT)
public class AccountService {
    @Autowired
    private AccountDao accountDao;
    /**
     * 转账
     * @param id1 转出人id
     * @param id2 转入人id
     * @param price 金额
     */
    // 作用于方法上时，该方法将都具有该类型的事务属性
    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT)
    public void transfer(int id1, int id2,double price) {
        // account1修改余额
        Account account1 = accountDao.findById(id1);
        account1.setBalance(account1.getBalance()-price);
        accountDao.update(account1);
        int i = 1/0; // 模拟转账出错
        // account2修改余额
        Account account2 = accountDao.findById(id2);
        account2.setBalance(account2.getBalance()+price);
        accountDao.update(account2);
   }
}
 
   
3 配置类代替xml中的注解事务支持：在配置类上方写 @EnableTranscationManagement
 
   
@Configuration
@ComponentScan("com.itbaizhan")
@EnableTransactionManagement
public class SpringConfig {
    @Bean
    public DataSource getDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
       druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
       druidDataSource.setUrl("jdbc:mysql:///spring");
       druidDataSource.setUsername("root");
       druidDataSource.setPassword("root");
        return druidDataSource;
}
    @Bean
    public SqlSessionFactoryBean getSqlSession(DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean;
   }
    @Bean
    public MapperScannerConfigurer getMapperScanner(){
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("com.itbaizhan.dao");
        return mapperScannerConfigurer;
   }
    @Bean
    public DataSourceTransactionManager getTransactionManager(DataSource dataSource){
         DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
      dataSourceTransactionManager.setDataSource(dataSource);
        return dataSourceTransactionManager;
   }
}
 
   
 
  
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(spring,学习,java)

        

            

                
    
                    
  • 情绪觉察日记第37天
                        露露_e800

                        
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）
                        研学随笔
arcgis经验分享
                        
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • 回溯 Leetcode 332 重新安排行程
                        mmaerd
Leetcode刷题学习记录leetcode算法职场和发展
                        
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
    
                    
    • 
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                    
  • 2019-12-22-22:30
                        涓涓1016

                        
    今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
    
                    
    • 
                    
  • 将cmd中命令输出保存为txt文本文件
                        落难Coder
Windowscmdwindow
                        
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
    
                    
    • 
                    
  • 四章-32-点要素的聚合
                        彩云飘过

                        
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • GitHub上克隆项目
                        bigbig猩猩
github
                        
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
    
                    
    • 
                    
  • 人工智能时代，程序员如何保持核心竞争力？
                        jmoych
人工智能
                        
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • 阶段总结反思
                        轻争

                        
    马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
    
                    
    • 
                    
  • ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    
                    
    • 
                    
  • ARM驱动学习之5 LEDS驱动
                        JT灬新一
嵌入式C底层arm开发学习单片机
                        
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
    
                    
    • 
                    
  • ARM驱动学习之4小结
                        JT灬新一
嵌入式C++arm开发学习linux
                        
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
    
                    
    • 
                    
  • 展现思维导图魅力，不断挖掘人生宝藏
                        思维导图讲师Mandy

                        
    第13期最强思维导图训练营已经结束一周了，但是我依旧是感觉所有学员还在努力的学习，这些学员中有教师、学生、白领、公务员、宝妈等等，只要你努力，只要你想改变自己，任何行业，任何岗位都可以参与进来，28天足以让你见成效，在这28天中，我们的学员不仅仅是收获了一枚毕业证，最重要的是让自己的思维方式得到升级，今天的你为自己投资，明天的你就会感谢你今天的付出，我们来听一听来自13期最强思维导图训练营优秀学员
    
                    
    • 
                    
  • 2019-3-23晨间日记
                        红红火火小耳朵

                        
    今天是什么日子起床：7点40就寝：23点半天气：有太阳，不过一会儿出来一会儿进去特别清爽的凉意，还蛮舒服的心情：小激动要给女朋友过生日啦纪念日：田田女士过生日任务清单昨日完成的任务，最重要的三件事：1.英语一对一2.运动计划3.认真护肤习惯养成：调整状态周目标·完成进度英语七天打卡（5/7）轻课阅读（87/180）音标课（25/30）读书（福尔摩斯一章）学习·信息·阅读#英语课#Cookingte
    
                    
    • 
                    
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面
                        一个射手座的程序媛
程序员华为od面试职场和发展
                        
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
    
                    
    • 
                                
  • java线程的无限循环和退出
                                    3213213333332132
java
                                    
    最近想写一个游戏，然后碰到有关线程的问题，网上查了好多资料都没满足。 
突然想起了前段时间看的有关线程的视频，于是信手拈来写了一个线程的代码片段。 
希望帮助刚学java线程的童鞋 
 

package thread;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date
    
                                
    • 
                                
  • tomcat 容器
                                    BlueSkator
tomcatWebservlet
                                    
    Tomcat的组成部分 1、server 
A Server element represents the entire Catalina servlet container. (Singleton) 2、service 
service包括多个connector以及一个engine，其职责为处理由connector获得的客户请求。 
  3、connector 
一个connector
    
                                
    • 
                                
  • php递归,静态变量,匿名函数使用
                                    dcj3sjt126com
PHP递归函数匿名函数静态变量引用传参
                                    
      
<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Current To-Do List</title>
</head>
<body>
    
                                
    • 
                                
  • 属性颜色字体变化
                                    周华华
JavaScript
                                    
    function changSize(className){ 
 
 var diva=byId("fot") 
 diva.className=className; 
 } 
</script> 
<style type="text/css"> 
 .max{ 
 background: #900; 
 color:#039; 
 
    
                                
    • 
                                
  • 将properties内容放置到map中
                                    g21121
properties
                                    
    代码比较简单： 
private static Map<Object, Object> map;
private static Properties p;

static {
	//读取properties文件
	InputStream is = XXX.class.getClassLoader().getResourceAsStream("xxx.properti
    
                                
    • 
                                
  • [简单]拼接字符串
                                    53873039oycg
字符串
                                    
             工作中遇到需要从Map里面取值拼接字符串的情况，自己写了个，不是很好，欢迎提出更优雅的写法，代码如下： 
          
import java.util.HashMap;
import java.uti
    
                                
    • 
                                
  • Struts2学习
                                    云端月影

                                    
    最近开始关注struts2的新特性，从这个版本开始，Struts开始使用convention-plugin代替codebehind-plugin来实现struts的零配置。 
配置文件精简了，的确是简便了开发过程，但是，我们熟悉的配置突然disappear了，真是一下很不适应。跟着潮流走吧，看看该怎样来搞定convention-plugin。 
使用Convention插件，你需要将其JAR文件放
    
                                
    • 
                                
  • Java新手入门的30个基本概念二
                                    aijuans
java新手java 入门
                                    
    基本概念:　　1.OOP中唯一关系的是对象的接口是什么,就像计算机的销售商她不管电源内部结构是怎样的,他只关系能否给你提供电就行了,也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的,不同的对象的访问通过函数调用来完成,对象间所有的交流都是通过方法调用,通过对封装对象数据,很大限度上提高复用率。　　2.OOP中最重要的思想是类,类是模板是蓝图,
    
                                
    • 
                                
  • jedis 简单使用
                                    antlove
javarediscachecommandjedis
                                    
    jedis.RedisOperationCollection.java 
package jedis;

import org.apache.log4j.Logger;
import redis.clients.jedis.Jedis;

import java.util.List;
import java.util.Map;
import java.util.Set;

pub
    
                                
    • 
                                
  • PL/SQL的函数和包体的基础
                                    百合不是茶
PL/SQL编程函数包体显示包的具体数据包
                                    
    由于明天举要上课,所以刚刚将代码敲了一遍PL/SQL的函数和包体的实现(单例模式过几天好好的总结下再发出来);以便明天能更好的学习PL/SQL的循环,今天太累了,所以早点睡觉,明天继续PL/SQL总有一天我会将你永远的记载在心里,,, 
  
函数; 
函数:PL/SQL中的函数相当于java中的方法;函数有返回值
定义函数的
--输入姓名找到该姓名的年薪
create or re
    
                                
    • 
                                
  • Mockito(二)--实例篇
                                    bijian1013
持续集成mockito单元测试
                                    
            学习了基本知识后，就可以实战了，Mockito的实际使用还是比较麻烦的。因为在实际使用中，最常遇到的就是需要模拟第三方类库的行为。 
        比如现在有一个类FTPFileTransfer，实现了向FTP传输文件的功能。这个类中使用了a
    
                                
    • 
                                
  • 精通Oracle10编程SQL(7)编写控制结构
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *编写控制结构
 */
 
--条件分支语句
--简单条件判断
DECLARE
  v_sal NUMBER(6,2);
BEGIN
  select sal into v_sal from emp
  where lower(ename)=lower('&name');
  if v_sal<2000 then
     update emp set
    
                                
    • 
                                
  • 【Log4j二】Log4j属性文件配置详解
                                    bit1129
log4j
                                    
    如下是一个log4j.properties的配置 
  
log4j.rootCategory=INFO, stdout , R

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appe
    
                                
    • 
                                
  • java集合排序笔记
                                    白糖_
java
                                    
    public class CollectionDemo implements Serializable,Comparable<CollectionDemo>{
	
	private static final long serialVersionUID = -2958090810811192128L;
	
	private int id;
	private String nam
    
                                
    • 
                                
  • java导致linux负载过高的定位方法
                                    ronin47

                                    
    定位java进程ID 
可以使用top或ps -ef |grep java
![图片描述][1]
 根据进程ID找到最消耗资源的java pid 
比如第一步找到的进程ID为5431
执行
top -p 5431 -H
![图片描述][2]
 打印java栈信息 
$ jstack -l 5431 > 5431.log
 在栈信息中定位具体问题 
将消耗资源的Java PID转
    
                                
    • 
                                
  • 给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数
                                    bylijinnan
函数
                                    
    
import java.util.ArrayList;
import java.util.List;
import java.util.Random;


public class RandNFromRand5 {

	/**
	 题目：给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数。
	 
	 解法1：
		 f(k) = (x0-1)*5^0+(x1-
    
                                
    • 
                                
  • PL/SQL Developer保存布局
                                    Kai_Ge

                                    
          近日由于项目需要，数据库从DB2迁移到ORCAL，因此数据库连接客户端选择了PL/SQL Developer。由于软件运用不熟悉，造成了很多麻烦，最主要的就是进入后，左边列表有很多选项，自己删除了一些选项卡，布局很满意了，下次进入后又恢复了以前的布局，很是苦恼。在众多PL/SQL Developer使用技巧中找到如下这段： 
  
&n
    
                                
    • 
                                
  • [未来战士计划]超能查派[剧透,慎入]
                                    comsci
计划
                                    
           非常好看,超能查派,这部电影......为我们这些热爱人工智能的工程技术人员提供一些参考意见和思想........ 
 
 
       虽然电影里面的人物形象不是非常的可爱....但是非常的贴近现实生活.... 
 
   &nbs
    
                                
    • 
                                
  • Google Map API V2
                                    dai_lm
google map
                                    
    以后如果要开发包含google map的程序就更麻烦咯 
 
http://www.cnblogs.com/mengdd/archive/2013/01/01/2841390.html 
 
找到篇不错的文章，大家可以参考一下 
 
http://blog.sina.com.cn/s/blog_c2839d410101jahv.html 
 
1. 创建Android工程 
由于v2的key需要G
    
                                
    • 
                                
  • java数据计算层的几种解决方法2
                                    datamachine
javasql集算器
                                    
    2、SQL 
    SQL/SP/JDBC在这里属于一类，这是老牌的数据计算层，性能和灵活性是它的优势。但随着新情况的不断出现，单纯用SQL已经难以满足需求，比如： JAVA开发规模的扩大，数据量的剧增，复杂计算问题的涌现。虽然SQL得高分的指标不多，但都是权重最高的。 
 
    成熟度：5星。最成熟的。 
  
    
                                
    • 
                                
  • Linux下Telnet的安装与运行
                                    dcj3sjt126com
linuxtelnet
                                    
     
Linux下Telnet的安装与运行       linux默认是使用SSH服务的 而不安装telnet服务    如果要使用telnet 就必须先安装相应的软件包    即使安装了软件包 默认的设置telnet 服务也是不运行的 需要手工进行设置   如果是redhat9，则在第三张光盘中找到   telnet-server-0.17-25.i386.rpm  
    
                                
    • 
                                
  • PHP中钩子函数的实现与认识
                                    dcj3sjt126com
PHP
                                    
    假如有这么一段程序： 
 
 function fun(){ 
  fun1(); 
  fun2(); 
 } 
 
  首先程序执行完fun1()之后执行fun2()然后fun()结束。 
  但是，假如我们想对函数做一些变化。比如说，fun是一个解析函数，我们希望后期可以提供丰富的解析函数，而究竟用哪个函数解析，我们希望在配置文件中配置。这个时候就可以发挥钩子的力量了。 
  我们可以在fu
    
                                
    • 
                                
  • EOS中的WorkSpace密码修改
                                    蕃薯耀
修改WorkSpace密码
                                    
    EOS中BPS的WorkSpace密码修改 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 201
    
                                
    • 
                                
  • SpringMVC4零配置--SpringSecurity相关配置【SpringSecurityConfig】
                                    hanqunfeng
SpringSecurity
                                    
     SpringSecurity的配置相对来说有些复杂，如果是完整的bean配置，则需要配置大量的bean，所以xml配置时使用了命名空间来简化配置，同样，spring为我们提供了一个抽象类WebSecurityConfigurerAdapter和一个注解@EnableWebMvcSecurity，达到同样减少bean配置的目的，如下： 
  
applicationContex
    
                                
    • 
                                
  • ie 9 kendo ui中ajax跨域的问题
                                    jackyrong
AJAX跨域
                                    
    这两天遇到个问题，kendo ui的datagrid，根据json去读取数据，然后前端通过kendo ui的datagrid去渲染，但很奇怪的是，在ie 10,ie 11,chrome,firefox等浏览器中，同样的程序， 
浏览起来是没问题的，但把应用放到公网上的一台服务器， 
却发现如下情况： 
 
 
1） ie 9下，不能出现任何数据，但用IE 9浏览器浏览本机的应用，却没任何问题 
 
    
                                
    • 
                                
  • 不要让别人笑你不能成为程序员
                                    lampcy
编程程序员
                                    
    在经历六个月的编程集训之后，我刚刚完成了我的第一次一对一的编码评估。但是事情并没有如我所想的那般顺利。 
说实话，我感觉我的脑细胞像被轰炸过一样。 
手慢慢地离开键盘，心里很压抑。不禁默默祈祷：一切都会进展顺利的，对吧？至少有些地方我的回答应该是没有遗漏的，是不是？ 
难道我选择编程真的是一个巨大的错误吗——我真的永远也成不了程序员吗？ 
我需要一点点安慰。在自我怀疑，不安全感和脆弱等等像龙卷风一
    
                                
    • 
                                
  • 马皇后的贤德
                                    nannan408

                                    
       马皇后不怕朱元璋的坏脾气，并敢理直气壮地吹耳边风。众所周知，朱元璋不喜欢女人干政，他认为“后妃虽母仪天下，然不可使干政事”，因为“宠之太过，则骄恣犯分，上下失序”，因此还特地命人纂述《女诫》，以示警诫。但马皇后是个例外。 
 
　　有一次，马皇后问朱元璋道：“如今天下老百姓安居乐业了吗？”朱元璋不高兴地回答：“这不是你应该问的。”马皇后振振有词地回敬道：“陛下是天下之父，
    
                                
    • 
                                
  • 选择某个属性值最大的那条记录（不仅仅包含指定属性，而是想要什么属性都可以）
                                    Rainbow702
sqlgroup by最大值max最大的那条记录
                                    
    好久好久不写SQL了，技能退化严重啊！！！ 
  
直入主题： 
比如我有一张表，file_info， 
它有两个属性（但实际不只，我这里只是作说明用）： 
file_code, file_version 
同一个code可能对应多个version 
现在，我想针对每一个code，取得它相关的记录中，version 值 最大的那条记录， 
SQL如下： 
select 
    *

    
                                
    • 
                                
  • VBScript脚本语言
                                    tntxia
VBScript
                                    
      
VBScript 是基于VB的脚本语言。主要用于Asp和Excel的编程。 
  VB家族语言简介 
  
 
 Visual Basic 6.0 
 
          源于BASIC语言。 
          由微软公司开发的包含协助开发环境的事
    
                                
    • 
                                
  • java中枚举类型的使用
                                    xiao1zhao2
javaenum枚举1.5新特性
                                    
    枚举类型是j2se在1.5引入的新的类型,通过关键字enum来定义,常用来存储一些常量. 
  1.定义一个简单的枚举类型 
public enum Sex {
	MAN,
	WOMAN
} 
  
枚举类型本质是类,编译此段代码会生成.class文件.通过Sex.MAN来访问Sex中的成员,其返回值是Sex类型. 
  2.常用方法 
静态的values()方
    
                                
    •