Spring学习

最新推荐文章于 2024-10-10 15:47:02 发布
最新推荐文章于 2024-10-10 15:47:02 发布
阅读量116 收藏
点赞数
分类专栏： java框架 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34429554/article/details/108961204
版权
本文详细介绍了Spring框架的核心功能，包括控制反转IOC、依赖注入DI的概念和实现，以及面向切面编程AOP的原理和在Spring中的应用。此外，还探讨了Spring的动态代理机制，包括静态代理和动态代理的区别和优势。最后，展示了Spring AOP在实际编程中的使用，包括切面、通知类型以及如何通过XML和注解配置切面。
摘要由CSDN通过智能技术生成

Spring

产生背景

目的：解决企业应用开发的复杂性。

功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能

范围：任何Java应用

前身: interface21框架。

​ Spring致力于J2EE应用的各层的解决方案，而不是仅仅专注于某一层的方案。可以说Spring是企业应用开发的“一站式”选择，并贯穿表现层、业务层及持久层。然而，Spring并不想取代那些已有的框架，而是与它们无缝地整合。

模块组成

image-20201006113035066

1、Spring core：核心容器

  • spring框架的基本功能，以bean的方式组织和管理Java应用中的各个组件及其关系，使用BeanFactory来产生和管理Bean，它是工厂模式的实现。主要实现控制反转IoC和依赖注入DI、Bean配置以及加载。

2、Spring AOP：Spring面向切面编程

  • 通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能集成到了Spring框架中。所以，可以很容易地使 Spring框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。AOP把一个业务流程分成几部分，例如权限检查、业务处理、日志记录，每个部分单独处理，然后把它们组装成完整的业务流程。每个部分被称为切面或关注点。

3、Spring context：Spring上下文

  • Spring上下文是一个配置文件，向Spring框架提供上下文信息。Spring上下文包括企业服务，如JNDI、EJB、电子邮件、国际化、校验和调度功能。提供框架式Bean访问方式，其他程序可以通过Context访问Spring的Bean资源。

4、Spring DAO

  • DAO模块主要目的是将持久层相关问题与一般的的业务规则和工作流隔离开来。Spring 中的DAO提供一致的方式访问数据库，不管采用何种持久化技术，Spring都提供一致的编程模型。Spring还对不同的持久层技术提供一致的DAO方式的异常层次结构。Spring的DAO模块对JDBC进行了再封装，隐藏了Connection、 Statement、ResultSet等JDBC API，使DAO模块直接继承JdbcDaoSupport类。

5、Spring ORM（Object Relation Mapper）对象关系映射模块

  • 方便ORM框架的集成，包括hibernate、JDO实现、TopLink和IBatis SQL Map等。Spring为所有的这些框架提供了模板之类的辅助类，达成了一致的编程风格。
    Spring的ORM模块对ORM框架如Hibernate等进行了封装，Spring能够管理、维护Hibernate，使用时可直接继承HibernateDaoSupport类，该类内置一个HibernateTemplate。Hibernate的配置也转移到Spring配置文件中。

6、Spring Web模块

  • Web模块建立在应用程序上下文模块之上，为基于Web的应用程序提供了上下文。Web层使用Web层框架，可选的，可以是Spring自己的MVC框架，或者提供的Web框架，如Struts、Webwork、tapestry和jsf。
  • Web模块用于整合Web框架，将Web框架也纳入Spring的管理之中。如Spring提供继承方式与代理方式整合Struts，继承方式不需要更改任何配置文件，只把Action继承自ActionSupport即可，但会对Spring产生依赖。代理方式需要在struts-config.xml中配置，由Spring全盘代理，因此可以使用Spring的各种资源、拦截器等。

7、Spring MVC

  • MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，MVC框架变成为高度可配置的。Spring的MVC框架提供清晰的角色划分：控制器、验证器、命令对象、表单对象和模型对象、分发器、处理器映射和视图解析器。Spring支持多种视图技术。

Spring core

IOC(控制反转)

什么是ioc

​ ioc英文全称为Inversion of Control，中文翻译为控制反转，意思为把控制权转让给对方，它是一种设计思想，在java中意思是把创建对象的过程（控制权）交 给第三方管理者，程序需要用到对象的时候直接去三方管理者取，从而实现对象之间的解耦。而spring容器就是这个第三方管理者，负责对象(bean)的创建和管 理。

​ 传统的对象间调用方式是利用组合耦合在一块，一旦某个被调用类的类名发生了改变，所有调用者耦合的地方都得修改，费时费力，利用spring容器管理只需要 修改相关配置即可，，从而降低对象之间的解耦性。

image-20201006150707661

image-20201006150756086

image-20201006150830965

例如（未使用容器之前）:

public interface UserDao {

    void  add();
}

public class UserDaoImpl implements UserDao {


    public void add() {
        System.out.println("hello spring");
    }
}

public interface UserService {

    void add();
}

public class UserServiceImpl implements UserService {

    UserDao userDao = new UserDaoImpl();

    public void add() {
        userDao.add();
    }
}

public class Test {

    public static void main(String[] args) {

        //调用业务层
        UserService userService = new UserServiceImpl();

        userService.add();
    }

}
image-20201006170607055

这里UserServiceImpl和UserDaoImpl耦合在了一块，假如UserDaoImpl名字发生了改变，那么所有耦合了UserDaoImpl的地方都得改名，耦合的地方少到可以手动修改，一旦存在多处耦合，那将会是很痛苦的一件事。

现在使用容器解决这个问题:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userDao"
          class="com.test.dao.UserDaoImpl">
    </bean>

</beans>

public class UserServiceImpl implements UserService {

    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

    UserDao userDao = (UserDao)context.getBean("userDao");

    public void add() {
        userDao.add();
    }

}

总结

使用spring管理后，只需要通过xml进行bean的注册(也可使用注解)，spring的bean容器会进行对象的创建和管理。

当某个类要使用对象时，直接去容器中取，而不是自己创建。

当被使用的对象类修改名或者要使用对应接口新实现的类对象时，只需要修改相关注册的地方类名，程序不用改动，从而实现解耦。

程序中需要面向接口编程（利用多态），否则没有意义。

DI(依赖注入)

​ 如果把ioc看作程序的一种解耦思想，那么di就是其思想的实现，依赖指的是bean对象的注入依赖于容器，注入指的是注入bean对象的属性。主要有以下几种注 入方式。

构造器注入
无参构造注入
public class User {

    String name;

    public User() {
        System.out.println("无参构造");
    }

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public void show(){
        System.out.println("name="+name);
    }

}

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--无参构造注入-->
   <bean id="user"  class="com.create.way.User">

    </bean>

</beans>
image-20201006181720458
有参构造注入

​ 下标注入

<!--有参构造下标注入-->
<bean id="user" class="com.create.way.User">
    <constructor-arg index="0" value="测试有参构造下标注入-"/>
</bean>

​ 类型注入

<!--有参构造类型注入-->
<bean id="user" class="com.create.way.User">
    <constructor-arg type="java.lang.String" value="测试有参构造类型注入"/>
</bean>

​ 名称注入

<bean id="user" class="com.create.way.User">
    <constructor-arg name="name" value="测试有参构造名称注入"/>
</bean>
set方式注入
javapublic class Student {

    private  String name;
    private  Address address;
    private  String[] books;
    private  List<String> hbbys;
    private  Map<String,String> card;
    private  Set<String> games;
    private  String wife;
    private Properties info;

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

    public void setAddress(Address address) {
        this.address = address;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public void setHbbys(List<String> hbbys) {
        this.hbbys = hbbys;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    public String getName() {
        return name;
    }

    public Address getAddress() {
        return address;
    }

    public String[] getBooks() {
        return books;
    }

    public List<String> getHbbys() {
        return hbbys;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public Set<String> getGames() {
        return games;
    }

    public String getWife() {
        return wife;
    }

    public Properties getInfo() {
        return info;
    }
    

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", books=" + Arrays.toString(books) +
                ", hbbys=" + hbbys +
                ", card=" + card +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

public class Address {

    private  String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

<!--<bean id="userDao"
      class="com.test.dao.UserDaoImpl">
</bean>-->

    <bean id="address"  class="com.test.di.Address">
        <property name="address" value="ankang"></property>
    </bean>

    <bean id="student" class="com.test.di.Student">
        <!--普通注入-->
        <property name="name" value="di测试"></property>
        <!--beam注入-->
        <property name="address" ref="address"></property>
        <!--数组注入-->
        <property name="books">
            <array>
                <value>"1"</value>
                <value>"2"</value>
                <value>"3"</value>
            </array>
        </property>
        <!--list注入-->
        <property name="hbbys">
            <list>
                <value>"a"</value>
                <value>"b"</value>
                <value>"c"</value>
            </list>
        </property>
        <!--map注入-->
        <property name="card">
            <map>
               <entry key="idcard" value="123"></entry>
                <entry key="account" value="456"></entry>
            </map>
        </property>
        <!--set注入-->
        <property name="games">
            <set>
                <value >"4"</value>
                <value >"5"</value>
                <value >"6"</value>
            </set>
        </property>
        <!--null注入-->
        <property name="wife">
            <null/>
        </property>
        <!--Properties注入-->
        <property name="info">
        <props>
            <prop key="a">a</prop>
            <prop key="b">b</prop>
            <prop key="c">c</prop>
        </props>
        </property>
    </bean>

</beans>

public class Test {

    public static void main(String[] args) {
        

        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        Student student = (Student)context.getBean("student");

        System.out.println(student.toString());

    }

}

image-20201006212541210

命名空间注入

​ P命名空间注入

public class People {
    String name;

    int age;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }

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

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

image-20201006214124556

​

​ c命名空间注入

image-20201006214715068

sping配置

别名
<alias name="user" alias="userNew"/>
bean的配置
<!--bean的配置
id:bean的唯一标识
class:bean的全限定名（包名+类名）
name:bean的别名，可取多个，用空格或者逗号和分号分割
-->
<bean id="user" class="com.create.way.User" name="u0 u1,u2;u3">
    <constructor-arg name="name" value="测试有参构造名称注入"/>
</bean>
import

可以将多个配置文件导入到一个里面，使用合并的那个就可以，便于团队合作。

例如存在三份配置文件beans、beans2、beans3，合并成一个applicationContext为：

<import resource="beans.xml"></import>
<import resource="beans2.xml"></import>
<import resource="beans3.xml"></import>
bean的作用域
image-20201006215314369

单例模式（默认）： 始终只有一个对象

​ image-20201006215706881

public class TestPanel {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans2");

        People people = context.getBean("people",People.class);
        People people2 = context.getBean("people",People.class);

        System.out.println(people==people2);


    }
}

image-20201006215819747

原型模式：每次从容器中取得时候都会创建一个新的对象。

public class TestPanel {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans2");

        People people = context.getBean("people",People.class);
        People people2 = context.getBean("people",People.class);

        System.out.println(people.hashCode());
        System.out.println(people2.hashCode());
        System.out.println(people==people2);


    }
}

image-20201006220216058

request、sessio、applicati在web开发中使用。

bean的自动装配

spring装配bean的三种方式

​ 1.xml配置（手动）

​ 2.java代码

​ 3.注解（自动)

ByName自动装配

​ 通过set后面的名去容器中自动查找对应的beanid相同的bean注入，beanid唯一

public class Cat {

    public  void shut(){
        System.out.println("猫叫了");
    }
}

public class Dog {

    public void  run(){
        System.out.println("狗跑了");
    }
}
image-20201006224431061 image-20201006224536153 
public class Test {

    public static void main(String[] args) {

      ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

      People people = context.getBean("people",People.class);

      people.getCat().shut();
      people.getDog().run();
    }
}

image-20201006224626165

ByType自动装配

​ 在容器中查找和自己属性对应类型相同的bean注入，只能有一个同类型的bean

image-20201006224940495

使用注解自动装配

​ jdk1.5，spring2.5开始支持

@Autowired

​ @Autowired可以用在属性上，也可以用在set方法上。

​ @Autowired的required默认为true，表示该属性不能为null，如果设置为false，则可以为null。

​ @Autowired可以和 @Qualifier搭配使用，指定beanid注入

public class People {

    //如果required设置为false，说明该属性可以为null
    @Autowired(required = false)
    Cat cat;
    
    @Autowired
    @Qualifier(value="dog1")
    Dog dog;

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }
}
@Resource

​ @Resource和@Autowired作用一样，都可以对bean进行自动装配。

​ @Autowired默认通过byType注入，如果存在多个bean，则通过byName注入

​ @Resource默认通过byName注入，如果找不到名，则通过byType注入

image-20201007101243352
其他常用的注解

在企业开发中，通常按照mvc模式分层，除了自动装配注解外，还有其他很多常用的注解。

​ @Component用于注册bean，相当于

<bean id="people"  class="com.test.autoried.People">
</bean>

​ @Scope(“prototype”)定义作用域，相当于

image-20201007104557310

​ @Value(“测试”)用于给属性设置，可用于属性和set方法上，相当于

image-20201007104923835

​ @Service、@Controller、@Repository常用于业务层、控制层、持久层，作用和@Component一样。

在开发中，如果要使用这些注解，必须现在对应的包下开启扫描。

<context:component-scan base-package="com.test.autoried"/>
<context:annotation-config/>

@Component
@Scope("prototype")
public class People {
    
    @Value("测试")
    String name;

    @Autowired
    Cat cat;

    @Autowired
    Dog dog;

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public String getName() {
        return name;
    }

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

xml配置和注解的比较

​ xml配置代码量较大，但便于统一管理。注解代码少，但管理比较分散。

​ 在实际开发中，二者可结合使用。

使用java配置bean

​ java配置相当于用一个java类取代xml文件的作用，是spring boot中常用的方式。JavaConfig是spring的一个子项目，是spring4后的核心功能。

//@Configuration表示一个配置类，其本身也是@Component，会被spring容器管理，相当于beans.xml
//@Import可以把多个配置类合成一个
@Configuration
@ComponentScan("pojo")
@Import(BeanConfig2.class)
public class BeanConfig {

    //注册一个bean，相当于bean标签，方法名相当于bean id
    //返回值相当于标签的class属性
    //return返回的就是注入的对象
    @Bean
    public User getUser(){
        return  new User();
    }

}


@Component
public class User {

    String name;

    public String getName() {
        return name;
    }

    @Value("测试config")
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class TestConfig {

    public static void main(String[] args) {
        //使用的时候需要用AnnotationConfig上下文获取
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
        User user = (User)context.getBean("user");
        System.out.println(user.getName());
    }
}

image-20201007120001789

代理模式

静态代理

​ 代理类是程序员写好的，编译期间代理类就确定

image-20201007130545323

角色分析

​ 抽象角色：一般使用抽象类或者接口。

​ 真实角色: 被代理的角色。

​ 代理角色：代理真实角色的角色，一般会额外做些事情(存在的意义)。

​ 客户：访问代理代理角色的对象。

。
   //接口
public interface House {

    void  sendKey();
}

//真实角色
public class HouseOwer implements House{
    @Override
    public void sendKey() {
        System.out.println("房东给钥匙！");
    }
}

//代理角色
public class Proxcy implements  House {

    private  HouseOwer houseOwer;

    public Proxcy(HouseOwer houseOwer) {
        this.houseOwer = houseOwer;
    }

    @Override
    public void sendKey() {
        conduct();
        houseOwer.sendKey();
        seeHouse();
    }

    public void conduct(){
        System.out.println("中介帮房东打广告！");
    }

    public void seeHouse(){
        System.out.println("中介带客户看房！");
    }
}

//客户
public class TestProcy {

    public static void main(String[] args) {
        HouseOwer houseOwer = new HouseOwer();
        Proxcy proxcy = new Proxcy(houseOwer);
        proxcy.sendKey();
    }
}

image-20201007132635679

代理模式的好处

​ 使真实角色更好的专注于自己的业务处理，其他公共处理交给代理角色。

​ 业务处理和公共处理由不同角色完成，实现了任务的分工，方便于公共业务的管理和扩展。

缺点

​ 一个真实角色对应一个代理角色，当有很多真实角色时，代码量会很大。

动态代理

​ 动态代理的代理类是在运行期间由处理程序动态生成的，角色划分和静态代理一样，常见的有jdk动态代理（只能代理接口）和Cglib动态代理，这里研究的时jdk 动态代理。

//生成代理类的类(处理程序)
public class ProxcyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成的代理类
    public Object getInstance(){
        return  Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }

    //处理代理实例
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        conduct();
        Object result = method.invoke(target,args);
        seeHouse();
        return  result;
    }


    public void conduct(){
        System.out.println("中介帮房东打广告！");
    }

    public void seeHouse(){
        System.out.println("中介带客户看房！");
    }

}

public class TestProcy {

    public static void main(String[] args) {

        //真实角色
        HouseOwer houseOwer = new HouseOwer();
        //生成代理类的对象
        ProxcyInvocationHandler proxcyInvocationHandler = new ProxcyInvocationHandler();
        //设置要代理的对象
        proxcyInvocationHandler.setTarget(houseOwer);
        //动态生成代理类
        House proxcy = (House)proxcyInvocationHandler.getInstance();

        proxcy.sendKey();

    }
}

image-20201007160548260

总结

​ 动态代理和静态代理具有同样的好处，但克服了静态代理中真实类必须手动编写代理类的缺点，而是由处理程序自动帮我们生成代理类，只要是真实类实现了相同接口，那么就可以调用处理程序为这些真实类生成对应的代理类，大大的节省了代码量，同时可以在处理程序的invoke方法调用前后加上想要的功能，spring的aop机制就是这个原理。

AOP编程思想

​ 在oop编程思想中，我们会根据事物的属性和特征进行分类，所以当我们想在一个方法调用前面或者后面加一些其他功能，例如日志、权限、事务等功能，我们一般会想到的是直接在对应方法前后进行功能添加，做的更高级一点，就是利用oop的思想将其封装成一个工具类或者一个父类，然后由业务类去继承父类或者直接调用工具类对应方法。但是这些都避免不了一个问题，我们的代码中一定会去显示的调用这些方法，而且会存在多处调用，一旦不需要某个功能了，我们必须手动去删除这些方法，不但费时费力，还增大了代码量，并且业务逻辑和这些功能耦合到了一块，功能的修改可能会影响到业务逻辑，所以aop思想出现了，其主要目的就是为了解决这一问题。

image-20201007180551767

​ 在aop编程思想中，为了解决这个问题，也会把这些功能抽取出来形成一个类(切面)，但这个类不会直接和业务类交互，而是通过一种机制(动态代理)在程序运行期间动态的把这个类里面的方法(通知)插入到业务类(目标)方法(切入点)的前后(连接点)，于是乎我们的业务代码在不做任何改动的情况下就添加了这些功能，从而实现了解耦，减少了代码的冗余，可以更加专注自己业务层的实现，这就是aop编程思想，也称面向切面编程。

image-20201007181657524

spring中的aop

​ Spring中的AOP可以认为是aop思想的一种实现，当然还是离不开Spring的IOC容器，代理的生成，管理及其依赖关系都是由IOC容器负责，Spring默认使用JDK动态代理，在需要代理类而不是代理接口的时候，Spring会自动切换为使用CGLIB代理，不过现在的项目都是面向接口编程，所以JDK动态代理相对来说用的还是多一些。aop中一些专业术语如下：

​ (1)Aspect(切面):通常是一个类，里面可以定义切入点和通知

​ (2)JointPoint(连接点):程序执行过程中明确的点，一般是方法的调用

​ (3)Advice(通知):AOP在特定的切入点上执行的增强处理，有before,after,afterReturning,afterThrowing,around

​ (4)Pointcut(切入点):就是带有通知的连接点，在程序中主要体现为书写切入点表达式

​ (5)AOP代理：AOP框架创建的对象，代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理，也可以是CGLIB代理，前者基于接口，后者基于子类

image-20201007183100098

Spring AOP 中有 5 中通知类型，分别如下：

image-20201007183257321

测试

使用sping的api定义切面

​ 首先导入aop所需要的包

<dependencies>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>
</dependencies>

public interface UserService {

    void  add();
    void  delete();
    void  update();
    void  select();
}

public class UserServiceImpl implements  UserService{
    public void add() {
        System.out.println("增加了一个用户");
    }

    public void delete() {
        System.out.println("删除了一个用户");
    }

    public void update() {
        System.out.println("修改了一个用户");

    }

    public void select() {
        System.out.println("查看了一个用户");

    }
}

public class BeforeLog implements MethodBeforeAdvice {

    //method:要执行的目标对象的方法
    //args：参数
    //target：目标对象
    public void before(Method method, Object[] args, Object target) throws Throwable {

        System.out.println(target.getClass().getName()+"的"+method.getName()+"方法被执行了");

    }
}

public class AfterLog implements AfterReturningAdvice {

    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+o);
    }
}

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userService"  class="com.aop.service.UserServiceImpl"/>
    <bean id="afterLog"  class="com.aop.log.AfterLog"/>
    <bean id="beforeLog"  class="com.aop.log.BeforeLog"/>

    <!--方式一-->
    <!--配置aop,需要导入aop约束-->
    <aop:config>
        <!--切入点，execution表示要执行的位置-->
        <aop:pointcut id="pointcut" expression="execution(* com.aop.service.UserServiceImpl.*(..) )"/>
        <!--执行环绕增强-->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>


    </aop:config>

</beans>

public class TestAop {

    public static void main(String[] args) {

        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserService userService = (UserService)context.getBean("userService");

        userService.add();

    }
}

image-20201007192108261

自定义切面
public class MyAspect {

    public void  before(){
        System.out.println("方法执行前.....");
    }
    public void  after(){
        System.out.println("方法执行后.....");
    }

}

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userService" class="com.aop.service.UserServiceImpl"/>
    <bean id="afterLog" class="com.aop.log.AfterLog"/>
    <bean id="beforeLog" class="com.aop.log.BeforeLog"/>

    <!--方式一 使用spring的api-->
    <!--配置aop,需要导入aop约束-->
    <!-- <aop:config>
         &lt;!&ndash;切入点，execution表示要执行的位置&ndash;&gt;
         <aop:pointcut id="pointcut" expression="execution(* com.aop.service.UserServiceImpl.*(..) )"/>
         &lt;!&ndash;执行环绕增强&ndash;&gt;
         <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
         <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
     </aop:config>-->

    <bean id="myAspect" class="com.aop.log.MyAspect"/>

    <!--方式二-->
    <!--自定义类-->
    <aop:config>
        <!--自定义切面-->
        <aop:aspect ref="myAspect">
            <!--切入点-->
            <aop:pointcut id="pointcut" expression="execution(* com.aop.service.UserServiceImpl.*(..) )"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="pointcut"/>
            <aop:after method="after" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>

</beans>

image-20201007194116872

使用注解配置
@Aspect //表示切面
public class AnnotationAspect {

    @Before("execution(* com.aop.service.UserServiceImpl.*(..) )")
    public void Before(){
        System.out.println("方法执行前.....");
    }

    @After("execution(* com.aop.service.UserServiceImpl.*(..) )")
    public void After(){
        System.out.println("方法执行后.....");
    }

    @Around("execution(* com.aop.service.UserServiceImpl.*(..) )")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕执行前");
        jp.proceed();
        System.out.println("环绕执行后");
    }

}

 <bean id="annotationAspect" class="com.aop.log.AnnotationAspect"/>
    <!--开启注解支持-->
    <!--
    proxy-target-class="false" 表示使用jdk动态代理，默认使用
    proxy-target-class="true" 表示使用cglib动态代理，一般不使用
    -->
    <aop:aspectj-autoproxy proxy-target-class="false"/>

image-20201007200009000

文章部分参考：https://www.cnblogs.com/jxxblogs/p/12143015.html

Vartimes
关注
专栏目录
spring 学习
08-04
由于提供的文件内容中存在大量重复的网址信息，并没有实际的教学内容或者相关知识点，我将从标题“spring 学习”出发，结合描述“通过搭建基本的工程，从中学习spring的原理”来详细阐述Spring框架的相关知识点。...
spring学习.zip
11-01
本资源集合围绕"spring学习.zip"，提供了多本深入讲解Spring及其相关技术的电子书籍，旨在帮助读者深入理解和掌握Spring生态。 1. **《深入实践Spring Boot.陈韶健.pdf》**：这本书详细介绍了Spring Boot，它是...
spring学习
03-07
spring系统学习，解读spring，源码解读 spring系统学习，解读spring，源码解读 spring系统学习，解读spring，源码解读
spring学习资源
10-12
学习spring资源书籍，第三版讲解的很全面，包括springmvc的整合
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 990
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1262
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 373
JDK1.0主要特性。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 598
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
2024Java最新面试题总结（针对于一些小厂、中厂）
weixin_62375676的博客
10-07 1097
2024最新Java面试题，针对一些小厂，中厂
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1432
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
SpringBoot线程问题
juanmiao的专栏
10-04 509
程序，线程，线程池进程是资源分配最小单位，线程是程序执行的最小单位。计算机在执行程序时，会为程序创建相应的进程，进行资源分配时，是以进程为单位进行相应的分配，每个进程都有相应的线程，在执行程序是，实际上是执行相应的一系列线程。线程：程序执行流的最小执行单位，是行程中实际运作单位，经常容易和进程这个概念混淆简单来说，一个应用程序的运行就可以被看做是一个进程。是运行中实际的执行任务者，可以说，进程中包含了多个可以同时运行的线程。线程的生命周期。
Python并发编程(1)——Python并发编程的几种实现方式
一点
10-03 1079
Python 并发编程是指在 Python 中编写能够同时执行多个任务的程序。并发编程在任何一门语言当中都是比较难的，因为会涉及各种各样的问题，在Python当中也不例外。Python 提供了多种方式来实现并发，包括多线程（threading）、多进程（multiprocessing）、异步编程（asyncio），以及一些高级用法concurrent.futures和第三方库如gevent。
Spring Boot新闻推荐系统设计与实现
2402_85758936的博客
10-04 1261
目前，界面设计已经成为对软件质量进行评价的一条关键指标，一个好的用户界面可以使用户使用系统的信心和兴趣增加，从而使工作效率提高，JSP技术是将JAVA语言作为脚本语言的，JSP网页给整个服务器端的JAVA库单元提供了一个接口用来服务HTTP的应用程序。一旦输入系统的数据不正确，那么处理后的输出就会扩大这些错误，因此输入的数据的准确性对整个系统的性能起着决定性意义。输出是由电脑对输入的基本信息进行解决，生成高质量的有效信息，并使之具有一定的格式，提供给管理者使用，这是输出设计的主要责任和目标。
【含开题报告+文档+PPT+源码】基于SSM框架的线上交易商城的设计与实现
码蜂窝编程-全网唯一毕设在线答疑，项目包运行成功，全套教学视频一站式辅导机构。
10-07 367
本课程演示的是一款校园二手交易系统，主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的 Java 学习者。包含：项目源码、项目文档、数据库脚本、软件工具等所有资料带你从零开始部署运行本套系统该项目附带的源码资料可作为毕设使用系统主要功能有：登录注册、公告管理、用户管理、商品管理、商品搜索、购物车、订单管理、用户私聊等模块。
Unsafe 详解
最新发布
qq_73210658的博客
10-10 1758
学习JUC的过程中发现有一个类很神奇，今天我们就来一起学习一下Unsafe类。
古典舞在线交流：SpringBoot平台实现与优化
2401_85341950的博客
10-04 708
在这段时期里，我查找了很多相关的资料，查阅了很多Java的相关文献，结合自己的经验，设计了这个古典舞在线交流平台，虽然每个学期学校都会针对动手练习进行相应的课程设计，但是在古典舞在线交流平台的具体设计中还是遇到了一些小问题，但在不断的学习、研究中都将问题一一解决，在一一克服的过程中，我也得到了成长，知识和经验也得到了丰富，这对我来说是一笔巨大的财富。这次设计也大大提高了我的动手的能力，让我在学习中充分体会到了探索的乐趣，享受成功的创作过程，在本次设计过程中汲取的东西，是一笔宝贵的财富，让我受益匪浅。
Java基础-基础知识体系小结 Q/A
令狐_JackieHao的博客
10-10 905
Java基础知识的一些梳理
Linux线程（十二）线程互斥锁-自旋锁与读写锁详解
Dola的博客
10-10 621
自旋锁与互斥锁很相似，从本质上说也是一把锁，在访问共享资源之前对自旋锁进行上锁，在访问完成后释放自旋锁（解锁）；事实上，从实现方式上来说，互斥锁是基于自旋锁来实现的，所以自旋锁相较于互斥锁更加底层。如果在获取自旋锁时，自旋锁处于未锁定状态，那么将立即获得锁（对自旋锁上锁）；如果在获取自旋锁时，自旋锁已经处于锁定状态了，那么获取锁操作将会在原地“自旋”，直到该自旋锁的持有者释放了锁。由此介绍可知，自旋锁与互斥锁相似，但是互斥锁在无法获取到锁时会让线程陷入阻塞等待状态；
Spring Boot驱动的现代医院管理系统
2401_85761003的博客
10-07 1206
6、网络上的客户端和服务器可以用来编程任何独立的编程环境，也有中国，GB2312，BIG5，日文写作，一般基金，用于支持多国语言，并且可以嵌入在数据表和其他软件shift_jis访问柱可以用作的名称。2、支持多种操作系统AIX的，FreeBSD下，HP-UX，Linux和Mac OS中，Novell公司的Netware，OpenBSD系统，OS/2裹时，Solaris，Windows等。编程语言，如C, C ++，Python和Java的，的Perl，PHP，埃菲尔铁塔，Ruby和Tcl的。
spring学习教程
02-09
好的，下面是一些 Spring 学习教程的建议： 1. 官方文档：Spring 官方网站提供了详细的文档和教程，包括 Spring 基础知识、配置、集成、Web 应用开发等内容。 2. 在线课程：慕课网、极客时间等在线视频教程网站都...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值