1.Spring

1.1、简介

​ 轻量级框架,Java EE的春天,当前主流框架!

1.2、优点

  • Spring是一个开源的免费的框架(容器)!

  • Spring是一个轻量级的、非入侵式的框架!

  • 控制反转(IOC),面向切面编程(AOP)!

  • 支持事务的处理,对框架集合的支持!

    总结:Spring就是一个轻量级的控制反转(IOC)和面向切面编程(AOP)的框架


2.IOC理论推导

  • 之前程序是主动创建对象,控制权在程序员手上
  • 使用set注入后,程序不再具有主动性,而是变成了被动的接收对象!
  • 这种思想,从本质上解决了问题,我们程序员不用再去管理对象的创建了。
  • 系统的耦合性大大降低~,可以更加专注地在业务的实现上!这是IOC的原型

2.1 控制反转为程序开发带来的好处是什么?**

​ 以前Dao是自己new出来的,编程完全控制在自己手里,通过Spring,初始化过程控制在容器手里,自己不用new它了,反转到容器里了

​ 原来我们的程序,我们控制的是具体的实现,写程序直接写实现。

现在我们控制的是它的接口,它的抽象。原来我们依赖的是它的实现,现在我们依赖的是它的抽象

​ 从具体的实现反转到抽象的概念上,我们针对的是接口编程,但真正注入进来的是具体的实现


2.2 面向切面编程的核心思想是什么?(AOP)

​ AOP在java里是利用反射机制实现的

​ 在不需要改变源代码的逻辑前提下,给系统的方法增加一些逻辑进去,并且这个逻辑是在整个程序的生命周期之内都能够应用.


3.IOC创建对象的方式

  1. 使用无参构造创建对象,默认!

  2. 假设我们要用有参构建创建对象

    1. 下标赋值

      <!--    第一种下标赋值!-->
      <bean id="user" class="com.chen.pojo.User">
      <constructor-arg index="0" value="赛飞"/>
      <constructor-arg index="1" value="男"/>
      </bean>
      
    2. 通过类型创建

      <!--    通过类型创建-->
      <bean id="user" class="com.chen.pojo.User"><constructor-arg type="java.lang.String" value="赛贵妃"/><constructor-arg type="java.lang.String" value="男"/>
      </bean>
      
    3. 通过参数名进行注入

      <!--    通过参数名进行注入--><bean id="user" class="com.chen.pojo.User"><constructor-arg name="gender" value="男"/><constructor-arg name="name" value="赛飞"/></bean>
      

    总结:在配置文件加载的时候,容器中管理的对象就已经被初始化了


4.Spring配置

4.1、别名

​ 如果添加了别名,我们也可以用别名获取到这个对象

    <alias name="user" alias="sdas"/>

4.2、Bean的配置

<!--    bean的配置id: bean 的唯一标识,也就是相当于我们学的对象名class: bean对象所对应的全限定类名,包名+类型name: 也是起别名,而且name可以同时起很多个,可用不同的分割(空格,逗号,分号)--><bean id="user" class="com.chen.pojo.User" name="user2 user3,user4;user5">

4.3、import

​ 一般用于团推开发使用,它可以将多个配置文件,,导入合并成一个

​ 假设现在项目中有多个人开发,这三个人负责不同的类开发,不同的类需要注册在不同的bean中,我们可以用import将所有人的bean.xml合并成一个总的。

  • 张三
  • 李四
  • 王五

5.依赖注入

5.1、构造器注入

​ 前面试过了

5.2、Set方式注入【重点】

  • 依赖注入:Set注入

    • 依赖:bean对象的创建依赖于容器
    • 注入:bean对象中的所有属性,由容器来注入!

    【环境搭建】

    1. 复杂类型

    2. 真实测试对象

      <bean id="student" class="com.bdqn.pojo.Student"><!--        第一种,普通注入 value--><property name="name" value="陈赛飞"/><!--        第二种,Bean注入 ref--><property name="address" ref="address"/><!--        第三种,数组注入--><property name="books"><array><value>红楼梦</value><value>西游记</value><value>水浒传</value><value>三国演义</value></array></property><!--        第四种,List注入--><property name="hobbys"><list><value>听歌</value><value>敲代码</value><value>打篮球</value></list></property><!--        第五种,Map注入--><property name="card"><map><entry key="身份证号" value="123456789012345678"/><entry key="银行卡" value="12344332442"/><entry key="手机号" value="123456778865"/></map></property><!--        第六种,Set--><property name="games"><set><value>LOL</value><value>COC</value><value>BOB</value></set></property><!--        第七种,空指针注入--><property name="wife"><null/></property><!--        第八种,特殊类型--><property name="info"><props><prop key="学号">2019201293</prop><prop key="QQ号">324234235</prop><prop key="性别">男</prop></props></property>
      </bean>
      

5.3、拓展方式注入

​ 我们可以使用,p命名空间和c命名空间进行注入

​ 官方解释:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-61LxMAeF-1603258955864)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201016165300104.png)]

​ 测试:

@Test
public void Student(){ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = (Student) context.getBean("student");
System.out.println(student);
}

​ 注意点:p命名和c命名空间不能直接使用,需要导入xml约束!

  1. p命名空间的作用:给属性赋值!
  2. c命名空间的作用:给有参构造函数的参数赋值!
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

6.Bean作用域(scope)

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cQ3tIsKb-1603258955870)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201016191459622.png)]

1.单例模式(默认机制)

​ singleton

<bean id="user" class="com.chen.pojo.User" name="user2" scope="singleton">

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jYPs6OWU-1603258955873)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201016191833227.png)]


2.原型模式

​ prototype 原型,每次从容器中get的时候,都会产生一个新对象

<bean id="user" class="com.chen.pojo.User" name="user2" scope="prototype">

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2s0bS17x-1603258955875)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201016192132673.png)]


3.其余的

​ request、session、application只能在web开发中使用到


7.Bean的自动装配

  • 自动装配Spring满足bean依赖一种方式!
  • Spring会在上下文中自动寻找,并自动改bean装配属性!

在Spring中有三种装配的方式

  1. 在xml中显示的配置
  2. 在java中显示配置
  3. 隐式的自动装配bean
    1. byName自动装配:根据自己对象的set方法的后面对应的name进行装配
    2. byType自动装配:根据自己对象属性类型相同的bean进行装配

使用注解实现自动装配

​ jdk1.5支持的注解,Spring2.5就支持注解了

​ 使用注解须知:

  1. 导入约束 context约束

  2. 配置注解配置 context:annotation-config/

    <?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:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsd"><context:annotation-config/></beans>
    

@Autowired

​ Spring支持的注解,优先查byType,其次查byName

​ 直接在属性上使用即可,也可以在set方式上使用!

​ 使用Autowired可以不编写set方法,因为它是用映射注入的

属性(required = false) 对象不可以为空 true:可以为空

@Qualifier(value = ‘xx’)

​ 指定自动装配的值,前提是类型相同的前提下

@Resource

​ java原生注解,优先查byName,其次查byType

​ 属性name:指定配置的name

小结

​ @Resource和@Autowired的区别:

  • 相同点

    1. 都可以放在属性字段上
  • 不同点

    1. @Resource先通过byName找,找不到名字再用byType类型
    2. @Autowired先通过byType找,找不到类型再用byName找名字

8.Bean的生命周期

  • 生命周期:从创建到销毁的全过程!

Bean的执行顺序:

  1. 通过配置文件,执行bean 先执行构造方法!
  2. 赋值时执行set方法
  3. 初始化前,执行后置处理器中的初始化前的方法Before
  4. 执行初始化方法
  5. 初始化后,执行后置处理器中的初始化后的方法after
  6. 从ioc中获取对象
  7. 销毁对象执行destroy方法

​ 设置后置处理器后,beans中的所有的bean在有初始化的方法时,都会执行后置处理器中的前后方法

​ 普通类实现BeanPostProcessor接口实现方法!


9.使用注解开发

  • 在Spring4之后,要使用注解开发,必须保证AOP包导入了
  • 在使用注解需要导入,context约束,增加注解的支持
  1. bean

    • @Component 组件,放在类上,说明这个类被Spring容器管理了,相等于bean了
  2. 属性如何注入

    • @Value(“xxx”) 注解注入,放在字段上,通过映射的方式去注入,不再用set方法了
  3. 衍生的注解

    • @Component 有几个衍生注解,我们在web开发中,会按照mvc三层分层!

      • dao【@Repository】
      • service【@Service】
      • controller【@Controller】
        • 这四个注解功能都是一样的,都是代表将某个类注册到Spring中装配Bean
  4. 自动装配

    1. @Autowired 自动装配通过类型 名字,自动装配,名字如果不能唯一,则

      • @Qualifier(value=‘xx’)
    2. @Nullable 字段标记了这个注解,说明这个字段可以为空
    3. @Resource 自动通过名字,类型
  5. 作用域

    1. @Scope(“singleton”) 单例
    2. @Scope(“prototype”) 原型
  6. 小结

    • xml与注解

      • xml:更加万能,适用于任何场合!维护简单方便
      • 注解:不是自己的类引用不了,维护相对复杂!

      最佳实践:

      • ​ xml用来管理bean
      • 注解只负责完成属性的注入
      • 我们在使用的过程中,只需要注意:要想让注解生效,就要开启注解支持和扫描包

10.使用java的方式配置Spring

​ 我们现在要完全不使用spring的xml配置了,全权交给java来做!

javaConfig是Spring的一个子项目,在Spring4之后,它成为了核心功能

  1. 创建一个类作为配置类

    1. @Configuration 类似于Beans 可以让这个类成为配置类
    2. @ComponentScan 扫描类
    3. @Bean 注册,相当于 bean标签
      • 其中 方法名 == bean的id属性
      • 其次 返回值 == bean的class
    • /*** @Configuration 让这个类成为配置类  类似与Beans*      它也会注册到Spring 容器中,因为它本身也是一个@Component* @ComponentScan 扫描类,* @Bean 注册到bean,相当于我们之前写的一个bean标签*      方法名字 == bean标签的id属性*      返回值 == bean标签中的class*/
      @Configuration![在这里插入图片描述](https://img-blog.csdnimg.cn/20201021134704788.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RoaXNBYXJvbg==,size_16,color_FFFFFF,t_70#pic_center)
      








 @ComponentScan("com.bdqn.pojo")@Import(ChenConfig2.class)public class ChenConfig {// 注册到bean,相当于我们之前写的一个bean标签@Beanpublic User getUser(){return new User();}} ```
  1. 创建要实例的类

    • Value(“xx”) 给属性赋值

    • // 让这个类注册到容器里
      @Component
      public class User {public String getName() {return name;}@Value("Aaron and Amder")public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +'}';}private String name;
      }
      

11.代理模式

​ 为什么要学习代理模式?因为这就是SpringAOP的底层 面试必问【SpringAOP 和 SpringMVC】

  • 代理模式的分类:

    • 静态代理
    • 动态代理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kik0D4pD-1603258955877)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201019184223032.png)]

11.1、静态代理

  • 角色分析:

    • 抽象角色:一般会使用接口或者抽象类来解决
    • 真实角色:被代理的而角色
    • 代理角色:代理真实角色,后我们一般会做附属操作
    • 客户:访问代理对象的人
  • 代码步骤:

    1. 接口

      public interface Rent {void rent();
      }
      
    2. 真实对象

      public class Host implements Rent{public void rent() {System.out.println("房东要出租房屋");}
      }
      
    3. 代理对象

      public class Proxy {private Host host;public Proxy() {}public Proxy(Host host) {this.host = host;}public void show(){host.rent();System.out.println("中介带客人去看房子");System.out.println("收中介费");System.out.println("签合同");System.out.println("拎包");}
      }
      
    4. 客户端访问代理对象

      public class Client {@Testpublic void shos(){Host host = new Host();Proxy proxy = new Proxy(host);proxy.show();}
      }
      
  • 代理模式的好处:

    • 可以让真实角色的操作更加纯粹!不用去关注公共业务
    • 公共业务交给代理角色!实现了业务的分工!
    • 公共业务发生扩展的时候,方柏集中管理!
  • 缺点

    • 一个真实角色就会产生一个代理对象,代码就会翻倍 开发效率会变低

11.2、加深理解

​ 代码步骤

  1. 接口

    public interface UserService {void add();void del();void upd();void sel();
    }
    
  2. 真实对象

    public class UserServiceimpl implements UserService{public void add() {System.out.println("增加一个用户");}public void del() {System.out.println("删除一个用户");}public void upd() {System.out.println("修改一个用户");}public void sel() {System.out.println("查询一个用户");}
    }
    
  3. 代理对象

    public class UserServiceProxy implements UserService {private UserServiceimpl userServiceimpl;public void setUserServiceimpl(UserServiceimpl userServiceimpl) {this.userServiceimpl = userServiceimpl;}public UserServiceProxy() {}public UserServiceProxy(UserServiceimpl userServiceimpl) {this.userServiceimpl = userServiceimpl;}public void add() {log4j("add");userServiceimpl.add();}public void del() {log4j("del");userServiceimpl.del();}public void upd() {log4j("upd");userServiceimpl.upd();}public void sel() {log4j("sel");userServiceimpl.sel();}public void log4j(String msg){System.out.println("使用了"+msg+"方法");}
    }
    
  4. 客户测试类

    public class Client {@Testpublic void cli(){UserServiceimpl serviceimpl = new UserServiceimpl();UserServiceProxy proxy = new UserServiceProxy(serviceimpl);proxy.add();}
    }
    

关于AOP实现图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DNWLzcOm-1603258955879)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201019194705749.png)]

11.3 动态代理

  • 动态代理和静态代理角色一样,
  • 动态代理的类是动态生成的,
  • 动态代理分为两大类
    • 基于接口的动态代理—JDK 动态代理
    • 基于类的动态代理—cglib
    • java字节码:javasist

需要了解两个类: Proxy 代理 ,invocationHandier 调用处理程序

  • 动态代理的好处

    1. 可以使真正角色的操作更加纯粹!不用去关注一些公共的业务
    2. 公共也就是交给代理角色!实现了业务的分工!
    3. 公共业务发生扩展的时候,方便集中管理!
    4. 一个动态代理类代理的是一个接口,一般就是对应的是一类业务
    5. 一个动态代理类可以代理多个类,只要是实现了同一个接口即可!

12.AOP

11.1 什么是AOP

​ AOP意为:面向切面编程,通过预编译方式和运行期动态代理实现从程序功能的统一维护的一种技术,AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生泛型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合降低,提高程序的可重用性,同时提高开发的效率

​ 在不通过修改源代码的方式,给他添加新功能!

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LAeHZWre-1603258955880)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201021084040174.png)]

11.2 AOP在Spring中的作用

提供声明式事务:允许用户自定义切面

  • 横向关注点:跨越应用程序多个模块的方法或功能,即使与我们业务逻辑无关的,但我们需要关注的部分,就是横切关注点。如日志,安全,缓存,事务等等…

  • 切面:切面 是通知和切入的结合,切入点:在哪干,通知:干什么

  • 通知:切面必须要完成的工作。 它是类中的一个方法

    1. 前置通知(@Before):方法前执行(一定执行)
    2. 后置通知(@AfterReturning): 方法后执行,目标方法没有异常 执行;有异常,不执行
    3. 异常通知(@AfterThrowing):方法发生异常时执行
    4. 最终通知(@After):相当于finally,,不论是否发生异常都执行
    5. 环绕通知(@Around): 前置,后置,异常,最终,四大增强方法的结合
  • 目标:被通知对象

  • 代理:向目标对象应用通知之后创建的对象

  • 切入点:实际被增强的方法 要加强的位置

  • 连接点:允许使用通知的地方 方法前后都是连接点

  • 织入:把切面应用到目标对象来创建新的代理对象的过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-stnWCDUF-1603258955883)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201020185637398.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oVoihvDN-1603258955884)(F:\Y2课程\SSM框架\Spring\笔记\img\image-20201020185734796.png)]

12.3 使用Spring实现AOP

【重点】使用AOP织入,需要导入一个依赖包!

<dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.6</version>
</dependency>

方式一: 使用Spring的API接口

  1. 创建接口和真实对象

    public interface UserService {void add();
    }public class UserServiceimpl implements UserService{public void add() {System.out.println("增加了一个用户");}
    }
    
  2. 创建要增强的日志

    public class AfterLog4j implements AfterReturningAdvice {// o 返回值public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {System.out.println("执行了"+method.getName()+"方法,返回结果为:"+o);}
    }public class log4j implements MethodBeforeAdvice {// method: 要执行的目标对象的方法// objects: 参数// o: 目标对象public void before(Method method, Object[] objects, Object o) throws Throwable {System.out.println(o.getClass().getName()+"的"+method.getName()+"被执行了");}
    }
    
  3. 配置文件

    <!--    注册bean--><bean id="userService" class="bdqn.chen.service.UserServiceimpl"/><bean id="log4j" class="bdqn.chen.log.log4j"/><bean id="afterLog4j" class="bdqn.chen.log.AfterLog4j"/><!--    配置aop:需要导入aop的约束--><aop:config>
    <!--    切入点--><aop:pointcut id="pointcut1" expression="execution(* bdqn.chen.service.UserServiceimpl.*(..))"/><!--    执行环绕--><aop:advisor advice-ref="log4j" pointcut-ref="pointcut1"/><aop:advisor advice-ref="afterLog4j" pointcut-ref="pointcut1"/></aop:config>
    

方式二:自定义来实现AOP

  1. 编写增强方法中的增强类

    public class Buftter {/*** 前置增强的方法*/public void buffer(JoinPoint joinPoint){System.out.println("前置增强");System.out.println(joinPoint.getSignature().getName());}/*** 无异常的方法*/public void afterReturning(){System.out.println("无异常的方法");}/*** 异常的方法*/public void afterthrowing(){System.out.println("异常的方法");}/*** 最终通知*/public void after(){System.out.println("最终通知");}/*** 环绕通知 ProceedingJoinPoint point*/public void around(ProceedingJoinPoint point){try {System.out.println("环绕前置增强...");Object proceed = point.proceed();System.out.println("环绕后置增强...");} catch (Throwable throwable) {throwable.printStackTrace();} finally {System.out.println("最终通知");}}
    }
    
  2. 配置切入点,切面,通知

    <!--方式二--><bean id="userService" class="bdqn.chen.service.UserServiceimpl"/><bean id="buftter" class="bdqn.chen.log.Buftter"/><aop:config><!--    切入点--><aop:pointcut id="poin" expression="execution(* bdqn.chen.service.UserServiceimpl.*(..))"/><!--        执行环绕--><aop:aspect ref="buftter"><aop:before method="buffer" pointcut-ref="poin"/><aop:after-returning method="afterReturning" pointcut-ref="poin"/><aop:after-throwing method="afterthrowing" pointcut-ref="poin"/><aop:after method="after" pointcut-ref="poin"/><aop:around method="around" pointcut-ref="poin"/></aop:aspect></aop:config>
    

方式三:注解实现AOP

  1. ​ 创建增强类

    • @Aspect 标注这个类是一个切面
    • @Before(“execution(* bdqn.chen.service.UserServiceimpl.*(…))”) 前置增强
    • @AfterReturning(“execution(* bdqn.chen.service.UserServiceimpl.*(…))”) 无异常增强
    • @AfterThrowing(“execution(* bdqn.chen.service.UserServiceimpl.*(…))”) 出现异常时增强
    • @After(“execution(* bdqn.chen.service.UserServiceimpl.*(…))”) 执行方法后增强
    • @Around(“execution(* bdqn.chen.service.UserServiceimpl.*(…))”) 环绕增强
    • 同时存在时执行的顺序
      1. @Around(环绕前)
      2. @Before(执行方法前)
      3. pjp.proceed() (执行方法)
      4. @Around(环绕后)
      5. @After(执行方法后)
      6. @AfterReturning/@AfterThrowing(执行有异常增强方法/执行无异常增强方法)
    @Aspect // 标注这个类是一个切面
    public class AnnotationPoinCut {@Before("execution(* bdqn.chen.service.UserServiceimpl.*(..))")       // 切入点public void before(JoinPoint joinPoint){System.out.println("执行"+joinPoint.getSignature().getName()+"方法前");}@AfterReturning("execution(* bdqn.chen.service.UserServiceimpl.*(..))")public void afterReturning(){System.out.println("无异常执行");}@AfterThrowing("execution(* bdqn.chen.service.UserServiceimpl.*(..))")public void afterThrowing(){System.out.println("出异常执行");}@After("execution(* bdqn.chen.service.UserServiceimpl.*(..))")public void after(){System.out.println("最终执行方法");}@Around("execution(* bdqn.chen.service.UserServiceimpl.*(..))")public void around(ProceedingJoinPoint pjp) throws Throwable {System.out.println("环绕前");Object proceed = pjp.proceed();System.out.println("环绕后");System.out.println(pjp.getSignature().getName());System.out.println(pjp.getSignature().getDeclaringType());System.out.println(pjp.getSignature().getDeclaringTypeName());System.out.println(pjp.getSignature());}
    }
    
  2. 配置中注册增强类

    <!--    方式三--><bean id="annotationPoinCut" class="bdqn.chen.diy.AnnotationPoinCut"/>
    <!--    开启注解支持!JDK(默认 proxy-target-class="false")  cglib(proxy-target-class="false")--><aop:aspectj-autoproxy proxy-target-class="true"/>
    

Joinpoint对象的使用

/**
* JoinPoint 对象做参数即可使用JoinPoint对象
*/
public void buffer(JoinPoint joinPoint){System.out.println("前置增强");System.out.println(joinPoint.getSignature().getName());
}









Spring的IOC和AOP课堂笔记相关推荐

  1. Spring中IOC和AOP的详细解释(转)

    原文链接:Spring中IOC和AOP的详细解释 我们是在使用Spring框架的过程中,其实就是为了使用IOC,依赖注入,和AOP,面向切面编程,这两个是Spring的灵魂. 主要用到的设计模式有工厂 ...

  2. Spring:IOC和AOP

    Spring:IOC和AOP 一. IOC (1) 引入 (2) 定义 (3) 作用 (4) 实现 (5) DI依赖注入 二. AOP (1) 概念 (2) Spring中的AOP (3) 入门案例 ...

  3. 彻底学会Spring的IOC和AOP——理论+实操

    目录 1 IOC 1.1 概念 1.2 底层原理 1.3 IOC容器 1.4 Bean管理:基于xml配置文件实现 1.5 两种类型的Bean 1.6 Bean的作用域 1.7 Bean的生命周期 1 ...

  4. Java 第一大框架:Spring 的 IoC 跟 AOP 雏形如何实现?

    Spring Spring make java more simple: Spring make java more modern: Spring make java more reactive: S ...

  5. Spring框架(IoC、AOP面向接口切面)

    新建一个Maven工程 Spring框架是由于软件开发的复杂性而创建的.Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情.然而,Spring的用途不仅仅限于服务器端的开发. ...

  6. 初学者快速了解spring的IOC和AOP原理

    spring框架概述 1.spring是轻量级的开源的javaEE框架 2.spring可以解决企业应用开发的复杂性 3.spring有两个核心部分:IOC和AOP (1)IOC:控制反转,把创建对象 ...

  7. spring中IoC和AOP的实现

    6.2 spring IoC IoC容器是Spring的核心.容器从配置文件中读取需要创建哪些对象,并在创建后按照要求把它们进行装配,通过这样的方法达到业务代码解耦的目的.不仅如此,spring还负责 ...

  8. Spring的IOC和AOP思想

    Spring框架的两大核心(ioc和aop) 一.ioc:控制反转(Inversion of Control)思想 1.1.由spring来负责控制对象的生命周期和对象间的关系(SSM框架中的依赖关系 ...

  9. Spring 的 IOC 和 AOP 简述

    首先IOC和AOP并不是Spring提出的,早在Spring之前就已经存在了,不过更偏向理论化,而Spring在技术层面将这两个理论做了很好的实现. 什么是IOC IoC: Inversion of ...

最新文章

  1. 基于OpenCV实战:绘制图像轮廓(附代码)
  2. Centos7 网络yum
  3. 表贴光电池 FU-NJL6402R-2 的特性
  4. 在线编译工具 Jenkins Hudson 的关系
  5. ES-PHP向ES批量添加文档报No alive nodes found in your cluster
  6. POJ 3801/HDU 3157 Crazy Circuits | 有下界的最小流
  7. java连接mongodb_第78天: Python 操作 MongoDB 数据库介绍
  8. 开发指南专题八:JEECG微云快速开发平台数据字典
  9. Java集合——概述
  10. c# 插入数据到 uniqueidentifier_每天5分钟用C#学习数据结构(16)二叉树 Part 2
  11. springboot增删改查案例_大神基于SpringBoot开发一个Restful服务,实现增删改查功能...
  12. iPhone被曝“窃听门” 用户在接听前可能被监听?苹果回应...
  13. Python基础----字符串
  14. 什么是最适合云数据库的架构设计?
  15. android获取上下文对象,如何在Android服务类中获取上下文
  16. 华为hs8145v5刷机包_华为hs8145v5刷机包_华为P40 Pro(ELSAN00/TN00)官方11.0.0.155固件卡刷包强刷包救砖包...
  17. 27_Pandas按星期,月份,季度和年份的天计算时间序列数据的总计和平均值
  18. python_生成器简介
  19. java Date days_JAVA的Date类与Calendar类(常用方法)
  20. [TYVJ 1927] 『Citric II』一道防AK好题 · 模拟

热门文章

  1. GEE学习笔记:在Google Earth Engine(GEE)中批量下载Sentinel-2影像
  2. WDZ-BYJ与普通BV电线的区别有哪些?
  3. 智慧社区数字孪生,助力物业数字化转型
  4. 文墨绘学:只有不会教的父母,没有教不好的孩子
  5. 交流电压和电流数据记录器的全球与中国市场2022-2028年:技术、参与者、趋势、市场规模及占有率研究报告
  6. ESP8266 基础篇:内存分布
  7. typescript TS 错误码大全
  8. 起源于 Kettle 的新一代数据集成平台 Apache Hop 成为 Apache 顶级项目
  9. AgNCs-NIPAM-AAc温度响应性银纳米簇荧光探针
  10. 拐点检测常用算法总结