参考博客: https://blog.csdn.net/qq_22583741/article/details/79589910

1.Spring框架是什么,为什么,怎么用

1.1 Spring框架是一种为了解决企业应用开发的复杂性而创建的开源框架. 其主要优势是分层架构,分层架构允许使用者选择使用哪一个组件,同时为J2EE应用程序开发提供集成的框架.Spring的核心是控制反转(IOC)和面向切面(AOP). 简单来说,Spring是一个分层的JavaSE/EE 一站式轻量级开源框架.

1.2 Spring是一个轻量级开源框架,它可以将简单的组件配置组合成为一个复杂的应用,它可以嵌合其它框架来组成一个完整有效的开发框架.

1.3 Spring的核心是IOC和AOP.  IOC代表着松耦合, 它使得一个对象需要其它对象时,不需要自己创建,而是通过Spring获取;  AOP允许了核心业务与其它业务的分离,使得核心业务只需要关注自己需要完成的时,而诸如日志,事务等则交给其它业务,有效地降低了业务逻辑各个部分之间的耦合性.

2. 内容概述

2.1 applicationContext.xml

这是Spring框架的一个核心文件, 无论是你使用xml进行依赖注入,还是使用注解, 都需要在这个文件中添加相关信息.

 

2.2 IOC

2.2.1 xml配置文件方式

2.2.1.1 属性注入

首先创建一个User对象,设置好你觉得需要的属性,然后将其通过<bean>标签放入配置文件中, 通过<property>标签设置获取到的对象的属性

  1. public class User {
  2. private int id;
  3. private int age;
  4. private String name;
  5.  
  6. public int getId() {
  7. return id;
  8. }
  9.  
  10. public void setId(int id) {
  11. this.id = id;
  12. }
  13.  
  14. public int getAge() {
  15. return age;
  16. }
  17.  
  18. public void setAge(int age) {
  19. this.age = age;
  20. }
  21.  
  22. public String getName() {
  23. return name;
  24. }
  25.  
  26. public void setName(String name) {
  27. this.name = name;
  28. }
  29. }
  1. <bean name="user" class="pojo.User">
  2. <property name="name" value="user1"></property>
  3. <property name="age" value="12"></property>
  4. </bean>

然后在主方法中通过ApplicationContext对象从Spring容器获取对象,而不是自己new一个对象. 可以检查获取到的对象是否有配置文件中设置的值.

  1. String contextfile = "applicationContext.xml";
  2. ApplicationContext context = new ClassPathXmlApplicationContext(contextfile);
  3. User u = (User)context.getBean("user");

2.2.1.2 对象注入

对象注入与属性注入类似, 就是将一个可以从Spring容器中获取的对象,注入到另一个对象中. 比如设置一本书有一个使用者,则获取书的时候,同时需要获取其使用者的对象

  1. public class Book {
  2. private int id;
  3. private String name;
  4. private User user;
  5.  
  6. public int getId() {
  7. return id;
  8. }
  9.  
  10. public void setId(int id) {
  11. this.id = id;
  12. }
  13.  
  14. public String getName() {
  15. return name;
  16. }
  17.  
  18. public void setName(String name) {
  19. this.name = name;
  20. }
  21.  
  22. public User getUser() {
  23. return user;
  24. }
  25.  
  26. public void setUser(User user) {
  27. this.user = user;
  28. }
  29. }

对应的配置为:

  1. <bean name="book" class="pojo.Book">
  2. <property name="name" value="book1"></property>
  3. <property name="user" ref="user"></property>
  4. </bean>

可以看到这里将value变为ref,指向了前面定义的 bean 中的内容, 因此获取书对象时,Spring也会注入用户对象

2.2.1.3 集合注入

在对象中需要用到集合时,需要用到的集合依赖注入,这里定义两个集合,一个集合里放基本类型,一个集合放对象

  1. package pojo;
  2.  
  3. import java.util.List;
  4. import java.util.Set;
  5.  
  6. public class Book {
  7. private int id;
  8. private String name;
  9. // private User user;
  10. private Set<String> stringSet;
  11. private List<User> users;
  12.  
  13. public int getId() {
  14. return id;
  15. }
  16.  
  17. public void setId(int id) {
  18. this.id = id;
  19. }
  20.  
  21. public String getName() {
  22. return name;
  23. }
  24.  
  25. public void setName(String name) {
  26. this.name = name;
  27. }
  28.  
  29. public Set<String> getStringSet() {
  30. return stringSet;
  31. }
  32.  
  33. public void setStringSet(Set<String> stringSet) {
  34. this.stringSet = stringSet;
  35. }
  36.  
  37. public List<User> getUsers() {
  38. return users;
  39. }
  40.  
  41. public void setUsers(List<User> users) {
  42. this.users = users;
  43. }
  44.  
  45. // public User getUser() {
  46. // return user;
  47. // }
  48.  
  49. // public void setUser(User user) {
  50. // this.user = user;
  51. // }
  52. }

在applicationContext.xml中的配置为:

  1. <bean name="book" class="pojo.Book">
  2. <property name="name" value="book1"></property>
  3. <property name="stringSet">
  4. <set>
  5. <value>啦啦啦</value>
  6. <value>312</value>
  7. <value>啦1啦</value>
  8. <value>啦2啦</value>
  9. </set>
  10. </property>
  11. <property name="users">
  12. <list>
  13. <ref bean="user"/>
  14. <ref bean="user"/>
  15. <ref bean="user"/>
  16. <ref bean="user"/>
  17. </list>
  18. </property>
  19. </bean>

在获取到book对象时,就可以从中得到注入的集合

2.2.2 注解方式

当你觉得使用xml文件太麻烦需要来回切换时,可以使用注解来简便快捷地进行依赖注入. 简单的属性注入注解主要用到@Component,@Autowired以及@Resource

  1. @Component("book")
  2. public class Book {
  3. private int id;
  4. private String name;
  5. @Resource(name = "user")
    //或者是@Autowired
  6. private User user;
  7.  
  8. //...setter,getter
  9. }
  1. @Component("user")
  2. public class User {
  3. private int id;
  4. private int age;
  5. private String name;
  6. //setter,getter
  7. }

但是需要在applicationContext.xml中添加几行信息,让Spring来扫描包进行注入

  1. <context:annotation-config/>
  2. <context:component-scan base-package="pojo"/>

2.3 AOP

2.3.1 xml方式

首先定义一个核心业务类, 做你需要做的事

  1. public class BookService {
  2.  
  3. public void addBook(Book book) {
  4. System.out.println("do something");
  5. }
  6. }

再定义一个切面类,用于对你需要的业务逻辑进行切面操作.  这里的joinPoint.proceed()可以看做是在进行业务类中的方法

  1. public class BookAspect {
  2.  
  3. public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
  4. //在目标业务进行前要做的东西
  5. System.out.println("start");
  6.  
  7. //目标业务进行时
  8. Object object = joinPoint.proceed();
  9.  
  10. //目标业务进行后的操作
  11. System.out.println("end ");
  12.  
  13. return object;
  14. }
  15. }

然后在applicationContext.xml文件中定义两个bean,并将两个方法"关联"起来,这样切面类中的方法就可以作用到业务类的方法中

  1. <!-- Service -->
  2. <bean id="bookServiceId" class="service.BookService"></bean>
  3.  
  4. <!-- Aspect -->
  5. <bean id="bookAspectId" class="aspect.BookAspect"/>
  6.  
  7. <!-- Aop -->
  8. <aop:config>
  9. <aop:pointcut id="bookCutpoint"
  10. expression="execution(* service.BookService.*(..))"/>
  11. <aop:aspect id="logAspect" ref="bookAspectId">
  12. <aop:around pointcut-ref="bookCutpoint" method="log"/>
  13. </aop:aspect>
  14. </aop:config>

2.3.2  注解方式

首先使用@Component注解,配置BookService类

  1. @Component("bookService")
  2. public class BookService {
  3.  
  4. public void addBook(Book book) {
  5. System.out.println("do something");
  6. }
  7. }

然后用@Aspect等注解,配置BookAspect类

  1. @Aspect
  2. @Component
  3. public class BookAspect {
  4.  
  5. @Around(value = "execution(* service.BookService.*(..))")
  6. public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
  7. //在目标业务进行前要做的东西
  8. System.out.println("start");
  9.  
  10. //目标业务进行时
  11. Object object = joinPoint.proceed();
  12.  
  13. //目标业务进行后的操作
  14. System.out.println("end ");
  15.  
  16. return object;
  17. }
  18. }

在applicationContext.xml中添加扫描业务类包和切面类包的信息,自动代理.  将两个类结合起来

  1. <context:component-scan base-package="aspect"/>
  2. <context:component-scan base-package="service"/>
  3. <aop:aspectj-autoproxy/>

Spring框架-IOC和AOP简单总结的更多相关文章

  1. Spring框架IOC和AOP介绍

    说明:本文部分内容参考其他优秀博客后结合自己实战例子改编如下 Spring框架是个轻量级的Java EE框架.所谓轻量级,是指不依赖于容器就能运行的.Struts.Hibernate也是轻量级的. 轻 ...

  2. Spring框架IOC和AOP的实现原理(概念)

    IoC(Inversion of Control) (1). IoC(Inversion of Control)是指容器控制程序对象之间的关系,而不是传统实现中,由程序代码直接操控.控制权由应用代码中 ...

  3. Spring框架IOC和AOP的实现原理

    IoC(Inversion of Control) (1). IoC(Inversion of Control)是指容器控制程序对象之间的关系,而不是传统实现中,由程序代码直接操控.控制权由应用代码中 ...

  4. Spring框架-IOC和AOP

    IOC:它并不是一种技术实现,而是一种设计思想.在任何一个有实际开发意义的程序项目中,我们会使用很多类来描述它们特有的功能,并且通过类与类之间的相互协作来完成特定的业务逻辑.这个时候,每个类都需要负责 ...

  5. Spring框架IOC容器和AOP解析 非常 有用

    Spring框架IOC容器和AOP解析   主要分析点: 一.Spring开源框架的简介  二.Spring下IOC容器和DI(依赖注入Dependency injection) 三.Spring下面 ...

  6. 简单理解Spring之IOC和AOP及代码示例

    Spring是一个开源框架,主要实现两件事,IOC(控制反转)和AOP(面向切面编程). IOC 控制反转,也可以称为依赖倒置. 所谓依赖,从程序的角度看,就是比如A要调用B的方法,那么A就依赖于B, ...

  7. Spring的IOC和AOP之深剖

    今天,既然讲到了Spring 的IOC和AOP,我们就必须要知道 Spring主要是两件事: 1.开发Bean:2.配置Bean.对于Spring框架来说,它要做的,就是根据配置文件来创建bean实例 ...

  8. spring的IOC和AOP

     spring的IOC和AOP 1.解释spring的ioc? 几种注入依赖的方式?spring的优点? IOC你就认为他是一个生产和管理bean的容器就行了,原来需要在调用类中new的东西,现在都是 ...

  9. Spring 的IOC和AOP总结

    Spring 的IOC和AOP IOC 1.IOC 许多应用都是通过彼此间的相互合作来实现业务逻辑的,如类A要调用类B的方法,以前我们都是在类A中,通过自身new一个类B,然后在调用类B的方法,现在我 ...

随机推荐

  1. Linux基本操作

    1. ctr + alt + t 打开新的终端窗口2. ctr + shift + + 终端窗口字体放大3. ctr + - 终端窗口字体缩小4. ls : 查看目录下的文件信息5. pwd: 查看目 ...

  2. UltraEdit文本行数多变一和一边多

    一.UltraEdit文本行数多行转换成一行 1.文本样式内容 1.qwertyuuiopqwertyuuiopqwertyuuiopqwertyuuiopqwertyuuiopqwertyuuiop ...

  3. url全部信息打印

    public String findAllContract(HttpServletRequest request,String a){ String string = new StringBuilde ...

  4. Python链表的实现与使用(单向链表与双向链表)

    参考[易百教程]用Python实现链表及其功能 """ python链表的基本操作:节点.链表.增删改查 """ import sys cl ...

  5. Servlet 易错点和注意点

    目录 @WebServlet("/")与@WebServlet("/*")的区别 @WebServlet("/")与@WebServlet( ...

  6. ansible 模块

    1. #vim /etc/ansible/yaml/back.yml - hosts: siyi tasks: - name: "yum rsync" yum: name=rsyn ...

  7. 小程序组件中有bindinput监听报异常

    真机上有问题,ide上是没问题的,   组件有处理函数,结果异常说页面没有处理函数,加上处理函数后就不报异常了.

  8. java gusnum

    package guss; import java.util.Scanner; public class gussnum { String myin; int y; public int gussnu ...

  9. ubuntu 安装 evpp

    ubuntu 安装 evpp 来源 https://www.cnblogs.com/wisdomyzw/p/9402440.html Ubuntu虚拟机安装开源库evpp说明: EVPP为奇虎360基 ...

  10. MSSQL-最佳实践-Always Encrypted

    摘要 在SQL Server安全系列专题月报分享中,往期我们已经陆续分享了:如何使用对称密钥实现SQL Server列加密技术.使用非对称密钥实现SQL Server列加密.使用混合密钥实现SQL S ...