spring笔记

spring框架实操：

1.下载spring5

2.创建普通Java项目

3.导入spring jar包

Corn ：beans，core，context，expression

4.创建普通的类，类中创建普通方法（eg：user类）

5.创建spring配置文件，在配置文件中配置创建的对象

（1）xml配置文件

6.测试代码

 

IOC容器：

什么是IOC:

控制反转，把对象的创建和调用都交给spring进行管理

使用IOC的目的，为了耦合度降低

1.IOC底层原理

(1)xml解析，工厂模式(为了降低耦合度)，反射

 

2.IOC接口(BeanFactory)

(1)IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

(2)Spring提供IOC容器实现两种方式，(两个接口)

1）BeanFactory：Spring内部的使用接口，不提供开发人员使用

*加载配置文件时不会创建对象，获取(使用)对象时才会去创建对象

2）ApplicationContext：Beanfactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用

*加载配置文件时就会把在配置文件中的对象进行创建

原因：

一个大项目启动时，就把这些耗时操作进行，耗时耗资源过程交给服务器，后面效率就高。

 

3）ApplicationContext接口实现类

(1)什么是Bean管理？

Bean管理指的是两个操作

1）Spring创建对象

2）Spring注入属性

(2)Bean管理操作有两种方式

1）基于xml配置方式

2）基于注解方式实现

3.IOC操作Bean管理(基于xml)

1.基于xml方式创建对象

<bean id="user" class="com.thexin.spring5.User"></bean>

(1)在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建

(2)在bean标签有很多属性，介绍常用的属性

id属性：唯一标识     class属性：类的全路径  name：和id类型，区别是name可以加符号

(3)创建对象时候，默认也是执行无参数的构造方法完成对象创建

2.基于xml方式注入属性

(1)DI：依赖注入，就是注入属性

第一种注入方式：set方法注入

1）类里面写set方法  2）spring配置文件里面bean中写property

3）test中ApplicationCoontext创建对象，之后getBean

第二种注入方式：有参构造注入

1）类中写有参构造方法  2）spring配置文件中bean中写constructor

第三种注入方式：p名称空间注入，可以简化基于xml配置方式

第一步：xsi替换为p

注入属性--外部Bean

(1)service类和dao类

(2)service中调用dao的方法

(3)spring配置文件中进行配置

bean的作用域：可以设置单实例还是多实例，默认是单实例。

bean的生命周期：

如果有后置处理器，那么生命周期会变为：

后置处理器在bean中配置

后置处理器会对这个配置文件中所有bean都设置后置处理器

IOC操作Bean(自动装配原理)

(1)什么是自动装配？

1）根据指定装配规则(属性名称或属性类型)，Spring自动将装配的属性进行注入

4.IOC操作Bean管理(基于注解)

完全注解开发：

替代了在xml中的配置

AOP：

1.有接口，JDK代理   2.没有接口，使用CGLIB代理

实现JDK:

JDK动态代理代码：

(1)创建接口，定义方法

public interface UserDao {
    public int add(int a,int b);
    public String update(String id);
}

(2)创建接口实现类，实现方法

public class UserDaoImpl implements UserDao{

    @Override
    public int add(int a, int b) {
        return a+b;
    }

    @Override
    public String update(String id) {
        return id;
    }
}

(3)使用Proxy类创建接口代理对象

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class JDKProxy {
    public static void main(String[] args){
        //创建接口实现类代理对象
        Class[] interfaces = {UserDao.class};
        /*Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return null;
            }
        });*/
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces,new UserDaoProxy(userDao));
        int result = dao.add(1,2);
        System.out.println(result);
    }
}

//创建代理对象代码
class UserDaoProxy implements InvocationHandler{
    //1.创建的是谁的代理对象，就把谁传递进来
    //通过有参构造
    private Object object;
    public UserDaoProxy(Object object){
        this.object = object;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法之前加个处理
        System.out.println("方法之前执行......"+method.getName()+" 传的参数："+ Arrays.toString(args));
        Object res = method.invoke(object,args);
        //方法之后加个处理
        System.out.println("方法之后执行......"+object);
        return res;
    }
    //增强的逻辑

}

AOP术语：

AOP准备工作：

引入jar包后：

其中权限修饰符可以不写，返回类型：*表示任意返回类型

AOP操作(AspectJ)：

(1)定义一个类

public class User {
    public void add(){
        System.out.println("add...");
    }
}

(2)创建增强类

public class UserProxy {
    //前置通知
    public void before(){
        System.out.println("before...");
    }
}

(3)进行通知的配置

1）在spring配置文件中，开启注解扫描

2）使用注解创建User，UserProxy对象

3）在增强的类上添加注解@AspectJ

4）在spring配置文件中开启生成代理对象

spring事务：

事务传播行为：