你能和面试官聊的spring 技术点有哪些，从哪里开始聊？

你能和面试官聊的spring 技术点有哪些，从哪里开始聊？

目前在我脑中关于spring 技术就是  大量的bean 配置， ioc 、aop  

ioc : 控制反转....

     控制反转是一种思想，就是创建对象从程序员原来的硬编码（手动new 对象），改成用set（）形式注入对象，只需要传入要引用的对象名称

public class UserServiceImpl implements UserService{

// 这里要引用userDao 对象 原来是硬编码的直接new
//    private UserDao userDao = new UserDaoImpl();
    private UserDao userdao;

    // 控制反转ioc （现在通过set 方法将要引用的对象直接传进来）
    public void setUserdao(UserDao userdao){
        this.userdao = userdao;
    }
    @Override
    public void getUser() {
        userdao.getUserById();
    }
}

public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
        UserServiceImpl userService = new UserServiceImpl();

        // 注入userDaoImpl  需要 传入new 对象
        userService.setUserdao(new UserDaoImpl());
        userService.getUser();
    }

}

spirng  的控制反转的实现是由DI （依赖注入）实现的，即如果想使用的对象 直接交给bean 容器，bean容器就是spring 管理对象的方式，他是通过bean.xml 配置对象的名称属性，然后通过ClassPathXMlapplicationContent （''bean.xml）对象 getBean("类名")获取。。。

aop： 面向切面编程.，首先要说说代理模式

1， 静态代理：

     正常的像实现类里面的每个方法都加一个调用日志的方法，由于开闭原则（开闭原则规定“软件中的对象（类，模块，函数等等）应该对于扩展是开放的，但是对于修改是封闭的”）

    不到万不得已，不要修改人家代码，（修改了会增加bug 发生率），IT行业的套娃理论出现了，就是说如果一个困难的事情解决不了，那就增加一层，还处理不了，那就在增加一层，所以这里就出现了代理模式，静态代理 ，

 就是增加一个代理类，实现要修改的 服务的接口interface ,实现接口所有服务，增加一个私有方法，log() 打印日志，还需引入要代理的类，使用set() 方法

Class Proxy{

private User uer;   

public void Set(User user){ this.user = user} //引入对象

......

}

2, 动态代理：

//动态代理类的模板，抽象实现

public class ProxyInvcationHandler Implents ProxyInvcationHandler

{

    //被代理的接口

    private Object target;

    public void setTarget(Object target){

        this.target = target

    }

 

    //生成得到代理类

    public Object getProxy(){

        return Proxy.newProxyInstance(this.getClass.getClassLoad(), this.getClass.rent.getClass.getInterfaces,this)

    }

    //处理代理类的实例，并返回结果

    public Object invock(Oject Proxy, Method method, Object[] args) throws Throwable {

        //动态代理的本质，就是使用反射机制实现的

        seeObject(); // 看对象

        Object result = method.invock(rent,args);

        seeFaimliy(); //像门户

        return result;

    }

    // 代理（媒人）干的活

    public void seeObject(){}

    public void seeFaimliy(){}

    public static void main (String[] args){

        UserServiceImpl UserService = New UserServiceImpl;

        //代理角色不存在

        ProxyInvcationHandler pih = new ProxyInvcationHandler();

        pih.setTarget(UserService);  // 设置要代理的对象

        Proxy.query();// 代理去执行 定亲操作

    }

}

Aop的概念是：面向切面编程，通过预编译和运行时动态代理实现程序功能的统一维护的一种技术，利用aop 可以对业务逻辑各个部分进行隔离，从而是业务逻辑各个部位分之间的耦合降低，提高程序可用性。

   使用方法：引入织入配置在pom中，定义配置类使用@Aspect  注解表示类（代替xml 配置文件）

  

package com.syxl.framework.config;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class Demo {
    @Before("execution(* com.syxl.system.service.impl.SysOperLogServiceImpl.*(..))")
    public void before(){

    }
    @After("execution(* com.syxl.system.service.impl.SysOperLogServiceImpl.*(..))")
    public void after(){

    }

    @Around("execution(* com.syxl.system.service.impl.SysOperLogServiceImpl.*(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {

      Object proceed = joinPoint.proceed() ;
    }


}