Spring使用与两大核心（Bean,AOP）

Spring框架

哈哈哈Spring官网的标题直接说明了我们为什么要使用spring。接下来我们看看一下Spring的使用步骤。

Spring入门使用

1.下载Spring依赖
先进入官网

点击进入github

进入后往下来，找到Access to Binaries
Access to Binaries

点击进入找到

找到发行版本


然后依次点击org/、springframework/、spring/、到达以下页面，选择你所需要的版本。

2.导入jar包，我们初期所需要的jar包为以下几个

博主在这里提供一个网盘链接，供大家直接下载。
提取码abcd
3.创建ApplicationContext.xml配置文件
注意下文件必须放在源文件夹，这里给出了3.2版本的头部。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

Spring轻松使用

spring的核心操作单元是以一个一个的bean为组件进行操作，因此我们需要知道bean是什么以及如何在xml文件中配置一个bean。

bean的定义：在 Spring 中，构成应用程序主干并由Spring IoC容器管理的对象称为bean。bean是一个由Spring IoC容器实例化、组装和管理的对象。
通过这段话我们大概明白了bean是由一个叫ioc容器帮我们创建的对象，不是我们自己创建的，bean由ioc容器实例化和管理。

（博主的个人理解：bean其实就对应着Java里面的对象，我们在Java中通过对象完成各种操作，Spring以封装好的bean给我们提供各种操作。注意：默认获取的bean是单例的。）

然后看看完上面相信你大概对bean有了个了解，但是此时你肯定又会由一个疑问那么ioc是什么东西？

ioc的定义：ioc（Inversion of Control）

控制反转通过依赖注入（DI）方式实现对象之间的松耦合关系。
程序运行时，依赖对象由【辅助程序】动态生成并注入到被依赖对象中，动态绑定两者的使用关系。 Spring
IoC容器就是这样的辅助程序，它负责对象的生成和依赖的注入，让后在交由我们使用。
简而言之，就是：IoC就是一个对象定义其依赖关系而不创建它们的过程。

控制反转一般可以这样理解，假设我们有一个User类（用户类）和一个Candy类（糖果类），用户都拥有自己的糖果。
我们的正常操作是自己手动创建用户对象，然后定义用户对象与某个糖果对象之间的依赖关系。
然后Spring提供的操作是，我们先定义好用户与糖果的依赖关系，然后spring通过ioc容器帮我们创建用户实例。
这就是对ioc的简单理解，我们在定义依赖关系的操作就叫做（DI）。

Spring的使用实例

1.定义Java程序类，程序类中有id，username，sign等对象属性。

public class User {
    private Integer id;
    private String username;
    private String sign;

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

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

    public String getSign() {
        return sign;
    }

    public void setSign(String sign) {
        this.sign = sign;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", sign='" + sign + '\'' +
                '}';
    }
}

2.定义dao层

public interface UserDao {
    public boolean addUser(User user);
}

3.设定实现类

public class UserDaoImpl implements UserDao {
    @Override
    public boolean addUser(User user) {
        System.out.println("-----------数据连接层daoImpl 正在执行-----------");
        System.out.println("需要添加的对象为"+user);
        System.out.println("-----------数据添加成功-----------------------");
        return true;
    }
}

4.定义service层

public interface UserService {
    public boolean addUser(User user);
}

5.设置实现类

public class UserServiceImpl implements UserService{

    UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public boolean addUser(User user) {
        return userDao.addUser(user);
    }
}

6.在xml文件中注册bean组件

    <bean id="userDao" class="com.openlab.dao.impl.UserDaoImpl"></bean>
    <bean id="userService" class="com.openlab.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>

可以看到，原来我们在userService中需要手动创建dao的实现类，现在我们通过xml文件进行实现类的依赖关系的定义。
7.测试程序

    @org.junit.Test
    public void testUserServiceAndAop(){
        ApplicationContext context =new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService service = (UserService) context.getBean("userService");
        User user = new User();
        user.setId(1001);
        user.setUsername("李淳罡");
        user.setSign("剑来");
        service.addUser(user);
    }

8.测试结果

AOP编程

AOP（Aspect-OrientedProgramming）下面以简单的图来看一下Aop到底是什么。

假设上面为我们正常程序的的执行流程，每一个方法的执行可以看为程序执行的一个节点（切入点），现在假设我们有一个需求，需要在执行C方法时加入一些新的代码，正常来说我们可能就需要更改源码，但是我们可以AOP编程，就可以避免更改源码。
面向切面编程通俗的说就是在某个切入点，我们增加新的方法来进行功能的解耦与拓展，使本来只需要执行一个节点方法的位置增加了（织入）许多个节点方法（多个点不就可以认为组成了一个面吗，而且相较于程序执行轴来说，这个些点理论上使增加在同一个时间点上的，所以是切面）。

实际上在Spring中实现AOP编程默认使用的是JDK中的动态代理模式来完成的。通过代理方法，实现增强处理。

AOP编程实例

在上面代码的基础上，我们对保存用户的功能进行拓展，在保存前先进行对象信息的打印（前置增强处理），在保存后打印方法的返回值（后置增强处理）
1.书写日志类（功能拓展）

public class UserLogger {
    private static final Logger LOGGER = Logger.getLogger(UserLogger.class);

    public void beforeProcess(JoinPoint joinPoint){
        System.out.println();
        System.out.println();
        System.out.println();
        System.out.println("---------前置增强服务正在执行------------");
        System.out.println("切点信息:切点执行方法"+joinPoint.getSignature().getName()+"切点方法所需要的参数+param"+ Arrays.toString(joinPoint.getArgs()));
        System.out.println("---------前置增强服务执行完毕------------");
        System.out.println();
        System.out.println();
        System.out.println();
    }
    public void afterProcess(JoinPoint joinPoint ,Object result){
        System.out.println();
        System.out.println();
        System.out.println();
        System.out.println("---------后置增强服务正在执行------------");
        System.out.println("切点信息:切点执行方法"+joinPoint.getSignature().getName()+"切点方法返回值为："+ result);
        System.out.println("---------后置增强服务执行完毕------------");
        System.out.println();
        System.out.println();
        System.out.println();
    }
}

2.将日志类注册为Java组件

 <!--配置增强服务类-->
    <bean id="userLogger" class="com.openlab.logger.UserLogger"></bean>

3.AOP配置

1. 配置切点
2. 配置切面
3. 配置增强处理

<!--aop配置-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.openlab.dao.UserDao.addUser(..))" ></aop:pointcut>
        <!--切面配置-->
        <aop:aspect ref="userLogger">
            <aop:before method="beforeProcess" pointcut-ref="pointcut"></aop:before>
            <aop:after-returning method="afterProcess" pointcut-ref="pointcut" returning="result"></aop:after-returning>
        </aop:aspect>
    </aop:config>

4.测试类

    @org.junit.Test
    public void testUserServiceAndAop(){
        ApplicationContext context =new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService service = (UserService) context.getBean("userService");
        User user = new User();
        user.setId(1001);
        user.setUsername("李淳罡");
        user.setSign("剑来");
        service.addUser(user);
    }

测试结果

博主才疏学浅，博文中难免存在错误，希望大家不吝指正！