Spring

第一章 初识Spring

1.1 Spring简介

1.2 搭建Spring框架步骤

1.3 Spring特性

1.4 Spring中getBean()三种方式

注意：框架默认都是通过无参构造器，帮助我们创建对象。

​ 所以：如提供对象的构造器时，一定添加无参构造器

1.5 bean标签详解

day06

第二章 SpringIOC底层实现

IOC：将对象的控制器反转给Spring

2.1 BeanFactory与ApplicationContexet

2.2 图解IOC类的结构

Spring

第三章 Spring依赖注入数值问题【重点】

3.1 字面量数值

3.2 CDATA区

3.3 外部已声明bean及级联属性赋值

Spring

3.4 内部bean

3.5 集合

第四章 Spring依赖注入方式【基于XML】

为属性赋值方式

  • 通过xxxset()方法
  • 通过构造器
  • 反射

4.1 set注入

4.2 构造器注入

4.3 p名称空间注入

导入名称空间：xmlns:p="http://www.springframework.org/schema/p"

第五章 Spring管理第三方bean

5.1 Spring管理druid步骤

第六章 Spring中FactoryBean

6.1 Spring中两种bean

6.2 FactoryBean使用步骤

package com.atguigu.factory;
import com.atguigu.pojo.Dept;
import org.springframework.beans.factory.FactoryBean;
/**
 * @author Chunsheng Zhang 尚硅谷
 * @create 2022/3/26 14:09
 */
public class MyFactoryBean implements FactoryBean<Dept> {
    /**
     * getObject():参数对象创建的方法
     * @return
     * @throws Exception
     */
    @Override
    public Dept getObject() throws Exception {
        Dept dept = new Dept(101,"研发部门");
        //.....
        return dept;
    }
    /**
     * 设置参数对象Class
     * @return
     */
    @Override
    public Class<?> getObjectType() {
        return Dept.class;
    }
    /**
     * 设置当前对象是否为单例
     * @return
     */
    @Override
    public boolean isSingleton() {
        return true;
    }
}

第七章 Spring中bean的作用域

7.1 语法

7.2 四个作用域

第八章 Spring中bean的生命周期

8.1 bean的生命周期

① 通过构造器或工厂方法创建bean实例

② 为bean的属性设置值和对其他bean的引用

③ 调用bean的初始化方法

④ bean可以使用了

⑤ 当容器关闭时，调用bean的销毁方法

8.2 bean的后置处理器

8.3 添加后置处理器后bean的生命周期

① 通过构造器或工厂方法创建bean实例

② 为bean的属性设置值和对其他bean的引用

postProcessBeforeInitialization(Object, String)：在bean的初始化之前执行

③ 调用bean的初始化方法

postProcessAfterInitialization(Object, String)：在bean的初始化之后执行

④ bean可以使用了

⑤ 当容器关闭时，调用bean的销毁方法

第九章 Spring中自动装配【基于XML】

9.1 Spring中提供两种装配方式

9.2 Spring自动装配语法及规则

9.3 总结

第十章 Spring中注解【非常重要】

10.1 使用注解将对象装配到IOC容器中

约定：约束>配置【注解>XML】>代码

位置：在类上面标识

注意：

  • Spring本身不区分四个注解【四个注解本质是一样的@Component】，提供四个注解的目的只有一个：提高代码的可读性
  • 只用注解装配对象，默认将类名首字母小写作为beanId
  • 可以使用value属性，设置beanId；当注解中只使用一个value属性时，value关键字可省略

10.2 使用注解装配对象中属性【自动装配】

第十一章 Spring中组件扫描

11.1 默认使用情况

<!--    开启组件扫描
        base-package：设置扫描注解包名【当前包及其子包】
-->
<context:component-scan base-package="com.atguigu"></context:component-scan>

11.2 包含扫描

<context:component-scan base-package="com.atguigu" use-default-filters="false">
    <context:include-filter type="annotation" 			 expression="org.springframework.stereotype.Repository"/>
    <context:include-filter type="assignable" expression="com.atguigu.service.impl.DeptServiceImpl"/>
</context:component-scan>

11.3 排除扫描

<!--    【排除扫描】   假设：环境中共有100包，不想扫描2/100-->
    <context:component-scan base-package="com.atguigu">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
<!--        <context:exclude-filter type="assignable" expression="com.atguigu.controller.DeptController"/>-->
    </context:component-scan>

第十三章 Spring完全注解开发【0配置】

13.1 完全注解开发步骤

  1. 创建配置类
  2. 在class上面添加注解
    • @Configuration：标识当前类是一个配置类，作用：代替XML配置文件
    • @ComponentScan：设置组件扫描当前包及其子包
  3. 使用AnnotationConfigApplicationContext容器对象

13.2 示例代码

/**
 * @author Chunsheng Zhang 尚硅谷
 * @create 2022/3/28 14:05
 */
@Configuration
@ComponentScan(basePackages = "com.atguigu")
public class SpringConfig {
}

  @Test
    public void test0Xml(){
        //创建容器对象
//        ApplicationContext context =
//                new ClassPathXmlApplicationContext("applicationContext.xml");
        //使用AnnotationConfigApplicationContext容器对象
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        DeptDaoImpl deptDao = context.getBean("deptDao", DeptDaoImpl.class);
        System.out.println("deptDao = " + deptDao);
    }

第十四章 Spring集成Junit4

14.1 集成步骤

  1. 导入jar包
    • spring-test-5.3.1.jar
  2. 指定Spring的配置文件的路径
    • 【@ContextConfiguration】
  3. 指定Spring环境下运行Junit4的运行器
    • @RunWith

14.2 示例代码

/**
 * @author Chunsheng Zhang 尚硅谷
 * @create 2022/3/28 14:12
 */
@ContextConfiguration(locations = "classpath:applicationContext.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class TestSpringJunit4 {
    @Autowired
    private DeptService deptService;
    @Test
    public void testService(){
        //创建容器对象
//        ApplicationContext context =
//                new ClassPathXmlApplicationContext("applicationContext.xml");
//        DeptService deptService = context.getBean("deptService", DeptServiceImpl.class);
        deptService.saveDept(new Dept());
    }
}

第十五章 AOP前奏

15.1 代理模式

Spring

15.2 为什么需要代理【程序中】

15.3 手动实现动态代理环境搭建

15.4 手动实现动态代理关键步骤

注意：代理对象与实现类【目标对象】是“兄弟”关系，不能相互转换

package com.atguigu.beforeaop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * @author Chunsheng Zhang 尚硅谷
 * @create 2022/3/28 16:22
 */
public class MyProxy {
    /**
     * 目标对象【目标客户】
     */
    private Object target;
    public MyProxy(Object target){
        this.target = target;
    }
    /**
     * 获取目标对象的，代理对象
     * @return
     */
    public Object getProxyObject(){
        Object proxyObj = null;
        /**
            类加载器【ClassLoader loader】,目标对象类加载器
            目标对象实现接口：Class<?>[] interfaces,目标对象实现所有接口
            InvocationHandler h
         */
        ClassLoader classLoader = target.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        //创建代理对象
        proxyObj = Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
            //执行invoke()实现动态织入效果
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //获取方法名【目标对象】
                String methodName = method.getName();
                //执行目标方法之前，添加日志
                MyLogging.beforeMethod(methodName,args);
                //触发目标对象目标方法
                Object rs = method.invoke(target, args);
                //执行目标方法之后，添加日志
                MyLogging.afterMethod(methodName,rs);
                return rs;
            }
        });
        return proxyObj;
    }
//    class invocationImpl implements InvocationHandler{
//    }
}

@Test
    public void testBeforeAop(){
//        int add = calc.add(1, 2);
//        System.out.println("add = " + add);
        //目标对象
        Calc calc = new CalcImpl();
        //代理工具类
        MyProxy myProxy = new MyProxy(calc);
        //获取代理对象
        Calc calcProxy = (Calc)myProxy.getProxyObject();
        //测试
//        int add = calcProxy.add(1, 2);
        int div = calcProxy.div(2, 1);
    }
标签 , , ,

发表回复