框架：spring

文章目录

一、spring
- 1.spring概述
- 2.Spring的优势
二、IOC
- 1.概述
- 2.依赖注入
- - （1）概述
  - （2）Bean的依赖注入入门
  - （3）Bean的依赖注入方式
  - （3）Bean的依赖注入的数据类型
  - （4）注解开发
三、AOP
- 1.概述
- 2.AOP 的作用及其优势
- 3.基于 XML 的 AOP 开发
- - （1）快速入门
  - （2）XML 配置 AOP 详解
  - （3）通知的类型
  - （4）切点表达式的抽取
- 4.基于注解的 AOP 开发
- - （1）快速入门
  - （2）注解配置 AOP 详解

一、spring 1.spring概述

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

提供了展现层 SpringMVC和持久层 Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架

解释上述的词汇：

轻量级
- api使用较简单
- 学习成本低
- 体积比较小
full-stack（全栈）：各层都有对应的解决的方案

2.Spring的优势

方便解耦，简化开发
AOP 编程的支持
声明式事务的支持
方便程序的测试
方便集成各种优秀框架
降低javaee api的使用难度

二、IOC 1.概述

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。(百度百科)

2.依赖注入（1）概述

依赖注入（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。

在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。

IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。

那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。

简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取

（2）Bean的依赖注入入门

创建 UserService，UserService 内部在调用 UserDao的save() 方法

public class UserServiceImpl implements UserService {
	@Override
	public void save() {
         ApplicationContext applicationContext = new 
                 ClassPathXmlApplicationContext("applicationContext.xml");       	           UserDao userDao = (UserDao) applicationContext.getBean("userDao");	
          userDao.save();
 	}
 }

将 UserServiceImpl 的创建权交给 Spring

从 Spring 容器中获得 UserService 进行操作

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) applicationContext.getBean("userService");
userService.save();

（3）Bean的依赖注入方式

构造方法

创建有参构造

private UserDao userDao;
public UserServiceImpl(UserDao userDao) {
	this.userDao = userDao;
}
public UserServiceImpl() {}

配置Spring容器调用有参构造时进行注入

set方法

在UserServiceImpl中添加setUserDao方法

配置Spring容器调用set方法进行注入

set方法:P命名空间注入

xmlns:p="http://www.springframework.org/schema/p"

直接new，会有什么问题

（3）Bean的依赖注入的数据类型

①普通数据类型

public class UserDaoImpl implements UserDao {
private String company;
    private int age;
    public void setCompany(String company) {
        this.company = company;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void save() {
        System.out.println(company+"==="+age);
        System.out.println("UserDao save method running....");   
    }
}

②引用数据类型

③集合数据类型

集合数据类型（List）的注入

public class UserDaoImpl implements UserDao {
	private List strList;
	public void setStrList(List strList) {
		this.strList = strList;
	}
	public void save() {
        System.out.println(strList);
        System.out.println("UserDao save method running....");
	}
}

集合数据类型（List）的注入

public class UserDaoImpl implements UserDao {
	private List userList;
	public void setUserList(List userList) {
	this.userList = userList;  
 }
public void save() {
	System.out.println(userList);
	System.out.println("UserDao save method running....");
	}
}

集合数据类型（ Map ）的注入

public class UserDaoImpl implements UserDao {
    private Map userMap;
    public void setUserMap(Map userMap) {
    this.userMap = userMap;
    }    
public void save() {      
	System.out.println(userMap);
	System.out.println("UserDao save method running....");
	}
}

集合数据类型（Properties）的注入

public class UserDaoImpl implements UserDao {
    private Properties properties;
    public void setProperties(Properties properties) {
        this.properties = properties;
    }
	public void save() {
		System.out.println(properties);
		System.out.println("UserDao save method running....");
	}
}

（4）注解开发

@Autowired使用在字段上用于根据类型依赖注入
@Qualifier结合@Autowired一起使用用于根据名称进行依赖注入
@Resource相当于@Autowired+@Qualifier，按照名称进行注入

//@Component("userService")
@Service("userService")
public class UserServiceImpl implements UserService {
    
    @Resource(name="userDao")
    private UserDao userDao;
    @Override
    public void save() {       
   	  userDao.save();
    }
}

@Value注入普通属性（比较重要的应用，下面会写到）

@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Value("注入普通数据")
    private String str;
    @Value("${jdbc.driver}")
    private String driver;
    @Override
    public void save() {
        System.out.println(str);
        System.out.println(driver);
        System.out.println("save running... ...");
    }
}

结合新注解

@PropertySource("classpath:jdbc.properties")
public class DataSourceConfiguration {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

三、AOP 1.概述

AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
OOP：面向对象编程

2.AOP 的作用及其优势

作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强
优势：减少重复代码，提高开发效率，并且便于维护

3.基于 XML 的 AOP 开发（1）快速入门

导入 AOP 相关坐标



  org.springframework
  spring-context
  5.0.5.RELEASE



  org.aspectj
  aspectjweaver
  1.8.13

创建目标接口和目标类（内部有切点）

public interface TargetInterface {    
	public void method();
}
public class Target implements TargetInterface {    
	@Override    
	public void method() {        
	System.out.println("Target running....");  
}}

创建切面类（内部有增强方法）

public class MyAspect {
    //前置增强方法
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

将目标类和切面类的对象创建权交给 spring

在 applicationContext.xml 中配置织入关系

测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
        target.method();
    }
}

（2）XML 配置 AOP 详解

切点表达式的写法：execution([修饰符] 返回值类型包名.类名.方法名(参数))）

访问修饰符可以省略
返回值类型、包名、类名、方法名可以使用星号* 代表任意
包名与类名之间一个点 . 代表当前包下的类，两个点 … 表示当前包及其子包下的类
参数列表可以使用两个点 … 表示任意个数，任意类型的参数列表

execution(public void com.itheima.aop.Target.method())	
execution(void com.itheima.aop.Target.*(..))
execution(* com.itheima.aop.*.*(..))
execution(* com.itheima.aop..*.*(..))
execution(* *..*.*(..))

（3）通知的类型

通知的配置语法：

（4）切点表达式的抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替 pointcut 属性来引用抽取后的切点表达式。

4.基于注解的 AOP 开发（1）快速入门

基于注解的aop开发步骤：

创建目标接口和目标类（内部有切点）

public interface TargetInterface {
    public void method();
}

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

创建切面类（内部有增强方法）

public class MyAspect {
    //前置增强方法
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

将目标类和切面类的对象创建权交给 spring

@Component("target")
public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}
@Component("myAspect")
public class MyAspect {
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

在切面类中使用注解配置织入关系

@Component("myAspect")
@Aspect
public class MyAspect {
    @Before("execution(* com.itheima.aop.*.*(..))")
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

在配置文件中开启组件扫描和 AOP 的自动代理

测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
        target.method();
    }
}

（2）注解配置 AOP 详解

注解通知的类型

切点表达式的抽取

同 xml配置aop 一样，我们可以将切点表达式抽取。抽取方式是在切面内定义方法，在该方法上使用@Pointcut注解定义切点表达式，然后在在增强注解中进行引用。具体如下：

@@Component("myAspect")
@Aspect
public class MyAspect {
    @Before("MyAspect.myPoint()")
    public void before(){
        System.out.println("前置代码增强.....");
    }
    @Pointcut("execution(* com.itheima.aop.*.*(..))")
    public void myPoint(){}
}

框架：spring

Java相关栏目本月热门文章