Spring框架-IOC和AOP简单总结

参考博客: 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进行依赖注入,还是使用注解, 都需要在这个文件中添加相关信息.

扫描二维码关注公众号，回复： 5755450 查看本文章

2.2 IOC

2.2.1 xml配置文件方式

2.2.1.1 属性注入

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

public class User {
    private int id;
    private int age;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

    <bean name="user" class="pojo.User">
        <property name="name" value="user1"></property>
        <property name="age" value="12"></property>
    </bean>

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

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

2.2.1.2 对象注入

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

public class Book {
    private int id;
    private String name;
    private User user;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

对应的配置为:

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

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

2.2.1.3 集合注入

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

package pojo;

import java.util.List;
import java.util.Set;

public class Book {
    private int id;
    private String name;
//    private User user;
    private Set<String> stringSet;
    private List<User> users;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Set<String> getStringSet() {
        return stringSet;
    }

    public void setStringSet(Set<String> stringSet) {
        this.stringSet = stringSet;
    }

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }

//    public User getUser() {
//        return user;
//    }

//    public void setUser(User user) {
//        this.user = user;
//    }
}

在applicationContext.xml中的配置为:

    <bean name="book" class="pojo.Book">
        <property name="name" value="book1"></property>
        <property name="stringSet">
            <set>
                <value>啦啦啦</value>
                <value>312</value>
                <value>啦1啦</value>
                <value>啦2啦</value>
            </set>
        </property>
        <property name="users">
            <list>
                <ref bean="user"/>
                <ref bean="user"/>
                <ref bean="user"/>
                <ref bean="user"/>
            </list>
        </property>
    </bean>

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

2.2.2 注解方式

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

@Component("book")
public class Book {
    private int id;
    private String name;
    @Resource(name = "user")
    //或者是@Autowired
    private User user;
    
    //...setter,getter
}

@Component("user")
public class User {
    private int id;
    private int age;
    private String name;
//setter,getter
}

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

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

2.3 AOP

2.3.1 xml方式

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

public class BookService {

    public void addBook(Book book) {
        System.out.println("do something");
    }
}

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

public class BookAspect { 

    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
                //在目标业务进行前要做的东西
        System.out.println("start");

                //目标业务进行时
        Object object = joinPoint.proceed();

               //目标业务进行后的操作
        System.out.println("end ");

        return object;
    }
}

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

 <!-- Service -->
<bean id="bookServiceId" class="service.BookService"></bean>

<!-- Aspect -->
<bean id="bookAspectId" class="aspect.BookAspect"/>

<!-- Aop -->
   <aop:config>
        <aop:pointcut id="bookCutpoint"
                      expression="execution(* service.BookService.*(..))"/>
        <aop:aspect id="logAspect" ref="bookAspectId">
            <aop:around pointcut-ref="bookCutpoint" method="log"/>
        </aop:aspect>
    </aop:config>

2.3.2 注解方式

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

@Component("bookService")
public class BookService {

    public void addBook(Book book) {
        System.out.println("do something");
    }
}

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

@Aspect
@Component
public class BookAspect { 

@Around(value = "execution(* service.BookService.*(..))")
    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
                //在目标业务进行前要做的东西
        System.out.println("start");

                //目标业务进行时
        Object object = joinPoint.proceed();

               //目标业务进行后的操作
        System.out.println("end ");

        return object;
    }
}

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

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

Spring框架-IOC和AOP简单总结

猜你喜欢