Spring笔记（动力节点）

Spring笔记 1.Spring开发步骤 1.创建maven项目，加入Maven依赖

  
  
      org.springframework
      spring-context
      5.3.10

2.创建普通的java类 3.创建Spring配置文件，在该文件里创建对象 4.单元测试（看对象是否创建了）

   @Test
    public void test(){
        String config="applicationContext.xml";
        ApplicationContext ac=new ClassPathXmlApplicationContext(config);
        Student student1=(Student) ac.getBean("student1");
        Student student2=(Student) ac.getBean("student2");
    }

2.Spring容器的工作原理 1.创建Spring容器（本质上是一个Map，用来存放java对象） 2.读取配置文件，组装bean标签，完成对象的创建和赋值 3.程序使用时再从Spring容器中取出对象 3.Ioc（控制反转）创建对象的方式 1.使用无参构造方法创建对象

2.使用有参构造方法来创建对象

4.Spring的配置 1.别名

使用alias标签来设置别名，可以设置多个别名

2.Bean的配置

3.团队合作

注意：若使用通配符（*）时，不能直接放在Resource目录下，要自己创建目录将所有的配置文件放在同一个目录下面.

5.依赖注入 1.Set注入(重点)

value:对简单类型的辅助, ref: 对引用数据类型的赋值

例如:

2.构造注入

语法：

3.引用数据类型的自动装入

语法：在bean标签中加入属性 autowire="byName或者bytype "

1.byName：引用数据类型和bean标签的id一样时，会完成自动注入

例如：

2.byType：要求引用数据类型数据和bean中对象必须时同源关系，且bean标签中对象必须时唯一的，不然会抛异常

同源关系：《1》同一个类《2》子类《3》接口和实现类

6.基于注解的依赖注入 1.开发步骤

1.创建maven项目，加入依赖

2.在类中加入Spring的注解例如：@Component

3.Spring配置文件中声明组件扫描器

如何加载属性配置文件：

在Spring配置文件中加入

2.Sping常用注解

1.@Component：调用无参构造，创建普通java对象

2.@Repository：创建Dao对象，访问数据库

3.@Service：创建Service对象，sevice是业务类对象

4.@Controller：创建控制器对象，接收用户请求，显示处理结果

5.@Value：对简单数据类型进行赋值

6.对引用数据类型赋值：

《1》@AutoWired：Spring提供的注解

默认使用byType：从容器中找出同源关系的对象进行赋值

使用byName：需要使用两个注解 @AutoWired赋值使用 @Qualifer：指定对象名称，使用这个名称对象完成赋值

《2》Resource：jdk提供

使用byType：Resource默认使用byName，如果byName失败，在使用byType 。

byName：指定resource的name属性，name是对象的名称

语法：（以Componenet为例）



@Component
public class Student {
    @Value("李四")
    private String name;

    @Value("28")
    private Integer age;

    @Autowired
    private PrimarySchool school;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public School getSchool() {
        return school;
    }

    public void setSchool(PrimarySchool school) {
        this.school = school;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }

    public Student() {
    }

    public Student(String name, Integer age,
                   PrimarySchool school) {
        this.name = name;
        this.age = age;
        this.school = school;
    }

7.Aop面向切面变成 1.相关介绍

作用：不该变原来的方法就可以对原来的方法进行增强操作

1.解耦合：业务功能和其他非业务功能之间解耦合

2.减少重复的代码

3.专注业务方法的实现，不用考虑其他的方法

基于动态代理的两种方式： 1.jdk动态代理（要求：需要一个类去继承另外一个类）

2.cglib代理（要求：接口和他的实现类）

2.开发步骤

1.创建maven项目，加入Spring的依赖和AspectJ依赖


  org.springframework
  spring-aspects
  5.3.5

2.创建普通的类，接口和他的实现类，定义相关方法，给相关方法经行增强操作

3.创建切面类

《1》在类上加入@Aspect注解

《2》在类中定义方法，方法里写对其他方法进行增强操作的代码，例如：在方法上使用@before（切入表达式）等注解

4.创建Spring配置文件

《1》完成对目标对象和切面对象的创建

《2》声明AspectJ框架中的自动生成器标签

5.创建测试类

3.常用注解

1.@Before:前置通知-在目标方法之前执行(重点)

案例：

//切面类中的代码，切面方法里面可以有JointPoint这个参数
    


    
@Aspect
public class MyAspect {

    @Before(value ="execution(public void com.bjpowernode.service.Demo01.MyServiceImpl.doSome())")
    public void doBefore(JoinPoint jp){
        Date date=new Date();
        System.out.println("前置通知执行了"+date);
    }
}

2.@AfterReturning:后置通知-在目标方法之后执行,能够获到目标方法的执行结果

案例：



@AfterReturning(value = "execution(* *..SomeServiceImpl.doOther(..))",
                returning = "res")
public void myAfterReturing(  JoinPoint jp  ,Object res ){
    // Object res:是目标方法执行后的返回值，根据返回值做你的切面的功能处理
    System.out.println("后置通知：方法的定义"+ jp.getSignature());
    System.out.println("后置通知：在目标方法之后执行的，获取的返回值是："+res);
    if(res.equals("abcd")){
        //做一些功能
    } else{
        //做其它功能
    }

    //修改目标方法的返回值， 看一下是否会影响 最后的方法调用结果
    if( res != null){
        res = "Hello Aspectj";
    }

}

3.@Around:环绕通知-在目标方法前和后都能执行,可以修改目标方法的执行结果,控制目标方法是否执行

案例：



@Around(value = "execution(* *..SomeServiceImpl.doFirst(..))")
public Object myAround(ProceedingJoinPoint pjp) throws Throwable {

    String name = "";
    //获取第一个参数值
    Object args [] = pjp.getArgs();
    if( args!= null && args.length > 1){
          Object arg=  args[0];
          name =(String)arg;
    }

    //实现环绕通知
    Object result = null;
    System.out.println("环绕通知：在目标方法之前，输出时间："+ new Date());
    //1.目标方法调用
    if( "zhangsan".equals(name)){
        //符合条件，调用目标方法
        result = pjp.proceed(); //method.invoke(); Object result = doFirst();

    }

    System.out.println("环绕通知：在目标方法之后，提交事务");
    //2.在目标方法的前或者后加入功能

    //修改目标方法的执行结果， 影响方法最后的调用结果
    if( result != null){
          result = "Hello AspectJ AOP";
    }

    //返回目标方法的执行结果
    return result;
}

4.@AfterThrowing:异常通知-在目标方法抛出异常时执行,通过Expection类型的参数,能够获取到异常信息

案例：



@AfterThrowing(value = "execution(* *..SomeServiceImpl.doSecond(..))",
        throwing = "ex")
public void myAfterThrowing(Exception ex) {
    System.out.println("异常通知：方法发生异常时，执行："+ex.getMessage());
    //发送邮件，短信，通知开发人员
}

5.@After:最终通知-总是在最后会被执行(常用来关闭资源)

案例：



@After(value = "execution(* *..SomeServiceImpl.doThird(..))")
public  void  myAfter(){
    System.out.println("执行最终通知，总是会被执行的代码");
    //一般做资源清除工作的。
 }

6.@PointCut:定义和管理切入点的注解

案例：

@After(value = "mypt()")
public  void  myAfter(){
    System.out.println("执行最终通知，总是会被执行的代码");
    //一般做资源清除工作的。
 }

@Before(value = "mypt()")
public  void  myBefore(){
    System.out.println("前置通知，在目标方法之前先执行的");
}


@Pointcut(value = "execution(* *..SomeServiceImpl.doThird(..))" )
private void mypt(){
    //无需代码，
}

4.切入点表达式

语法: execution(value=(访问权限返回值方法声明异常类型)) 中间用空格分开

注意:1.方法的声明必须是全限定名称:包+类+方法名称 2.访问权限和异常类型可以不写

//切入点表达式的举例   
    @Before(value ="execution(public void com.bjpowernode.service.Demo01.MyServiceImpl.doSome())")
    public void doBefore(){
        Date date=new Date();
        System.out.println("前置通知执行了"+date);
    }
//切入点表达式如何使用通配符
* :代表一个或者多个字符

.. :用在方法后面,表示任意个参数;用在包后,表示当前包及其子包
 
+ :用在类后,表示子类;用在接口后面,表示当前接口的实现类

8.Spring集成MyBatis 1.开发步骤

步骤：
1.新建maven项目
2.加入maven的依赖
  1）spring依赖
  2）mybatis依赖
  3）mysql驱动
  4）spring的事务的依赖
  5）mybatis和spring集成的依赖： mybatis官方体用的，用来在spring项目中创建mybatis
     的SqlSesissonFactory，dao对象的
3.创建实体类
4.创建dao接口和mapper文件
5.创建mybatis主配置文件
6.创建Service接口和实现类，属性是dao。
7.创建spring的配置文件：声明mybatis的对象交给spring创建
 1）数据源DataSource
 2）SqlSessionFactory
 3) Dao对象
 4）声明自定义的service
8.创建测试类，获取Service对象，通过service调用dao完成数据库的访问


  org.springframework
  spring-context
  5.3.5



  org.mybatis
  mybatis
  3.5.1




  org.springframework
  spring-tx
  5.3.5



  org.springframework
  spring-jdbc
  5.3.5




  mysql
  mysql-connector-java
  8.0.25


  

  org.mybatis
  mybatis-spring
  1.3.1




  com.alibaba
  druid
  1.2.6

2.开发举例子

1.创建maven项目，加入maven依赖

2.创建实体类对象

public class Student {
    //属性名和列名一样。
    private Integer id;
    private String name;
    private String email;
    private Integer age;

    public Student() {
    }

    public Student(Integer id, String name, String email, Integer age) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + ''' +
                ", email='" + email + ''' +
                ", age=" + age +
                '}';
    }
}

3.创建Dao接口和对应的mapper文件

StudentDao接口：

public interface StudentDao {
    int insertStudent(Student student);
    List selectStudents();
}

对应的Mapper文件（StudentDao.xml)



    
        insert into student values(#{id},#{name},#{email},#{age})

4.创建MyBatis主配值文件

MyBatis.xml文件：

5.创建Service接口和实现类，属性是Dao的属性

Service接口：

public interface StudentService {

    int addStudent(Student student);
    List queryStudents();
}

接口对应的实现类：

public class StudentServiceImpl implements StudentService {

    //引用类型
    private StudentDao studentDao;

    //使用set注入，赋值
    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
    }

    @Override
    public int addStudent(Student student) {
        int nums = studentDao.insertStudent(student);
        return nums;
    }

    @Override
    public List queryStudents() {
        List students = studentDao.selectStudents();
        return students;
    }
}

7.创建spring的配置文件：声明mybatis的对象交给spring创建
创建4个对象：1.数据源对象（DataSource） 2.SqlSession对象 3.Dao对象 4.Service对象

7.创建测试类，测试能否拿到数据

@Test
public void testServiceSelect(){

    String config="applicationContext.xml";
    ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
    //获取spring容器中的dao对象
    StudentService service = (StudentService) ctx.getBean("studentService");

    List students = service.queryStudents();
    for (Student stu:students){
        System.out.println(stu);
    }
}

9.Spring事务开发步骤（两种方式）

实现步骤：
1.新建maven项目
2.加入maven的依赖
  1）spring依赖
  2）mybatis依赖
  3）mysql驱动
  4）spring的事务的依赖
  5）mybatis和spring集成的依赖： mybatis官方体用的，用来在spring项目中创建mybatis
     的SqlSesissonFactory，dao对象的
3.创建实体类
  Sale, Goods
4.创建dao接口和mapper文件
  SaleDao接口 ，GoodsDao接口
  SaleDao.xml , GoodsDao.xml

5.创建mybatis主配置文件
6.创建Service接口和实现类，属性是saleDao, goodsDao。
7.创建spring的配置文件：声明mybatis的对象交给spring创建
 1）数据源DataSource
 2）SqlSessionFactory
 3) Dao对象
 4）声明自定义的service

8.创建测试类，获取Service对象，通过service调用dao完成数据库的访问

一.使用@TranSaction注解的方式：这种方式适合中小型项目

1.加入Spring依赖（Spring-tx）

2.在配置文件中声明事务管理器（再Spring配置文件中）

3.开启事务注解驱动，告诉Spring框架现在是使用注解处理事务

4.在Service方法中加入@Transactional注解



 //使用的是事务控制的默认值， 默认的传播行为是REQUIRED，默认的隔离级别DEFAULT
 //默认抛出运行时异常，回滚事务。
 @Transactional
 @Override
 public void buy(Integer goodsId, Integer nums) {
     System.out.println("=====buy方法的开始====");
     //记录销售信息，向sale表添加记录
     Sale sale  = new Sale();
     sale.setGid(goodsId);
     sale.setNums(nums);
     saleDao.insertSale(sale);

     //更新库存
     Goods goods  = goodsDao.selectGoods(goodsId);
     if( goods == null){
         //商品不存在
         throw  new  NullPointerException("编号是："+goodsId+",商品不存在");
     } else if( goods.getAmount() < nums){
         //商品库存不足
         throw new NotEnoughException("编号是："+goodsId+",商品库存不足");
     }
     //修改库存了
     Goods buyGoods = new Goods();
     buyGoods.setId( goodsId);
     buyGoods.setAmount(nums);
     goodsDao.updateGoods(buyGoods);
     System.out.println("=====buy方法的完成====");
 }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FkmoXRRk-1636096729906)(C:UsersASUSAppDataRoamingTyporatypora-user-imagesimage-20211022152650665.png)]

二.使用aspectj框架的aop方式：适合大型项目

开发步骤：

1.加入aspect依赖（Spring-aspects）

2.在配置文件中声明事务对象管理器（Spring配置文件中）

3.配置事务的通知（切面）：使用tx:advice配置方法的事务属性

4.配置增强器（配置切入点表达式）

2.事务相关介绍

1.事务的隔离级别

mysql默认的是可重复度，orcle默认的是可重复读

2.事务的传播行为

3.超长时间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BlL6oXYD-1636096729909)(C:UsersASUSAppDataRoamingTyporatypora-user-imagesimage-20211022151803170.png)]

Spring事务提交和回滚的实际：

1.当业务方法正常执行时，Spring框架会在方法执行后自动提交事务

2.当业务方法抛出异常时，Spring会执行事务回滚rollback

Spring笔记（动力节点）

Java相关栏目本月热门文章