Spring

快速入门

Spring是一个管理Bean的容器,一个轻量级框架

  • 使用Spring,需要引入对应的依赖下载地址

        
            UTF-8
            5.1.5.RELEASE
         
      
            
            
                org.springframework
                spring-web
                ${springFramework.version}
            
            
                org.springframework
                spring-webmvc
                ${springFramework.version}
            
            
                org.springframework
                spring-context
                ${springFramework.version}
            
            
                org.springframework
                spring-jdbc
                ${springFramework.version}
            
            
                org.springframework
                spring-test
                ${springFramework.version}
            
            
            
                org.apache.logging.log4j
                log4j
                2.10.0
            
            
                commons-logging
                commons-logging
                1.2
            
        
    
  • 管理对象,必须是一个接口一个实现类

    /**
     * 战士
     */
    public interface Fighter {
        void show();
    }
    
    /**
    * 吕布,战士类的一个实现类
    */
    public class LvBu implements Fighter {
        public void show() {
            System.out.println("战士吕布");
        }
    }
    

IOC控制反转/DI依赖注入

回顾历史

之前我们创建对象的方式,是在一个类中主动new另一个类的对象,然后再调用其方法完成功能

public class Main {
    public static void main(String[] args) {
        // 获取对象 -- 以前的方式,主动创建
        Fighter f1 = new LvBu();
        f1.show();
    }
}

Main类掌握着Fighter类型对象的控制权(想创建就创建),这样带来一个缺点,当许多模块都需要使用Fighter类型对象时,一旦Fighter类型对象需要发生改变,需要大量的修改其他模块的代码才能满足需求,所以,Spring提出了一种新的获取对象的方式 -- 配置

spring配置文件

spring.xml




    
    
    
    


public class Main {
    public static void main(String[] args) {
        // 获取对象 -- 以前的方式,主动创建
//        Fighter f1 = new LvBu();
//        f1.show();

        // Spring的方式获取对象,需要把对象配置在xml文件中
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Fighter lvbu = (Fighter)applicationContext.getBean("lvbu");
        Fighter guanyu = (Fighter)applicationContext.getBean("guanyu");
        lvbu.show(); // 战士吕布
        guanyu.show(); // 战士关羽
    }
}

使用配置的方式带来一个好处,当Fighter类型对象需要改变的时候,我们只需要修改spring.xml就可以了,不需要修改其他模块,便利了开发

IOC控制反转

对于java应用程序来说,对象的控制权逆转了,这个概念称为IOC--控制反转。
之间调用或创建对象都是交给java应用程序来完成,现在交给spring来分配。

DI依赖注入

对于spring来说,配置一个对象,相当于对其他调用者注入了一个可调用的对象

IOC控制反转和DI依赖注入没有区别,只是针对参照物不同的不同说法

属性注入
  • 构造器注入(前提:必须有有参构造器)

    
    
    
    public class GuanYu implements Fighter {
        private String name;
        private int age;
        public GuanYu() {}
        public GuanYu(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public void show() {
            System.out.println(name+","+age);
        }
    }
    
    
    
        
        
        
        
        
    
    

    复杂对象

    
    
        
            
            
            
        
        
        
            
        
    
    

    集合

  • setter注入

    
        
        
        
    
    

    复杂对象

    
    
        
            
            
            
        
        
        
            
        
    
    

    集合

        
            
            
            
            
            
                
                    张飞
                    马超
                
            
            
            
                
                    
                    
                
            
            
            
                
                    
                    
                
            
            
            
                
                    
                    
                
            
        
    
  • 接口注入(Spring不支持)

自动装配(了解)






    


    



    
    
    
    
        
    
    
        
    

package com.neuedu.test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

public class GuanYu implements Fighter {
    private String name = "关羽";
    @Autowired
    @Qualifier("test2")// 转配的com.neuedu.test.Fang
    private Weapon weapon;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
    public void show() {
        System.out.println(name);
        weapon.showInfo();
    }
}

注解自动装配(重要)

spring.xml配置扫描包



    
    

public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        GuanYu guanyu = (GuanYu)applicationContext.getBean("guanyu");
        guanyu.show();
    }
}
@Component("test1")
public class QingLong implements Weapon {
    private int dps;
    public void setDps(int dps) {
        this.dps = dps;
    }
    public int getDps() {
        return dps;
    }
    public void showInfo() {
        System.out.println("青龙偃月,攻击力很高");
    }
}
@Component("test2")
public class Fang implements Weapon {
    private int dps;
    public void setDps(int dps) {
        this.dps = dps;
    }
    public int getDps() {
        return dps;
    }
    public void showInfo() {
        System.out.println("方天画戟,攻击力很高");
    }
}
@Component
public class GuanYu implements Fighter {
    private String name = "关羽";
    @Autowired
    @Qualifier("test2")
    private Weapon weapon;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
    public void show() {
        System.out.println(name);
        weapon.showInfo();
    }
}

@Component:标记类,交给spring统一管理。(不同层,用的)
@Autowired:注入依赖。
@Qualifier("test2"):注入依赖具体的名字。

类型 说明

@Component 通用的构造型注解,标示该类为Spring 组件。

@Controller 标识将该类定义为Spring MVC controller。

@Repository 标识将该类定义为数据仓库(例如:Dao层)。

@Service 标识将该类定义为服务(例如:Service层)。

AOP面向切面编程

一般应用在如性能检测、访问控制、事务控制、日志记录等

![*](file:///C:\Users\ADMINI~1\AppData\Local\Temp\artD302.tmp)切面(Aspect)

![*](file:///C:\Users\ADMINI~1\AppData\Local\Temp\artD312.tmp)切面是切点和通知组成,通知和切点共同定义了切面的全部内容即:它是什么,在何时何处完成其功能;

![*](file:///C:\Users\ADMINI~1\AppData\Local\Temp\artD313.tmp)连接点(Joinpoint)

![*](file:///C:\Users\ADMINI~1\AppData\Local\Temp\artD314.tmp)连接点是在应用执行过程中能够插入切面的一个点,Spring仅支持方法的连接点,即仅能在方法调用前,方法调用后,方法抛出异常时及方法调用前后插入切面代码。

![*](file:///C:\Users\ADMINI~1\AppData\Local\Temp\artD315.tmp)切点(Pointcut)

![*](file:///C:\Users\ADMINI~1\AppData\Local\Temp\artD316.tmp)切点定义了在何处应用切面,AOP通过“切点”定位特定的连接点。切点相当于查询条件,一个切点可以匹配多个连接点。

![*](file:///C:\Users\ADMINI~1\AppData\Local\Temp\artD317.tmp)通知(Advice)

![*](file:///C:\Users\ADMINI~1\AppData\Local\Temp\artD318.tmp)切面的工作被成为通知,定义了切面是什么及何时使用。除了描述切面要完成的工作,通知还解决了何时执行这个工作的问题,它应该在某个方法被调用之前?之后?等。

![*](file:///C:\Users\ADMINI~1\AppData\Local\Temp\artD319.tmp)Spring切面可以应用5种类型的通知:

![*](file:///C:\Users\ADMINI~1\AppData\Local\Temp\artD32A.tmp)前置通知(Before)在目标方法被调用之前调用通知功能;

![*](file:///C:\Users\ADMINI~1\AppData\Local\Temp\artD32B.tmp)后置通知(After)在目标方法被完成之后调用通知功能,不关心方法的输出是什么;

![*](file:///C:\Users\ADMINI~1\AppData\Local\Temp\artD32C.tmp)环绕通知(Around advice)通知包裹了目标方法,在目标方法调用之前和之后执行自定义的行为;

![*](file:///C:\Users\ADMINI~1\AppData\Local\Temp\artD32D.tmp)异常通知(After-throwing)在目标方法抛出异常后调用通知;

![*](file:///C:\Users\ADMINI~1\AppData\Local\Temp\artD32E.tmp)返回通知(After-returning)在目标方法成功执行之后调用通知;

你可能感兴趣的:(Spring)