Spring学习记录-01

最新推荐文章于 2024-08-04 11:07:52 发布
最新推荐文章于 2024-08-04 11:07:52 发布
阅读量183 收藏
点赞数 1
分类专栏： spring学习记录 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43572551/article/details/105424565
版权

目录

一、Spring简介

1. Spring是什么？

spring是全栈式(full-stack)的轻量级开源框架，IOC（控制反转）和AOP（面向切面编程）是其内核，提供了展现层Spring MVC和持久层Spring JDBC以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE企业应用开源框架。

2.Spring的优势

  1. 方便解耦，简化开发;
  2. AOP编程的支持;
  3. 声明式事务的支持;
  4. 方便程序的测试;
  5. 方便集成各种优秀框架;
  6. 降低JavaEE API的使用难度;
  7. Java源码是经典学习范例;

3.Spring的体系结构

Spring的结构

二、程序的耦合

1.何为程序的耦合？

  • 软件工程中，耦合指对象之间的依赖性。耦合越高，维护成本越高。因此在开发过程中要使类和构件之间的耦合最小。软件设计中划分模块的准则就是高内聚低耦合。

2.何为解耦？

  • 即降低程序间的依赖关系。
  • 在实际开发中应该做到：编译期不依赖，运行时才依赖。

例如：在以前我们的JDBC操作，注册驱动时，为什么不使用DriverManager的register方法，而是采用Class.forName的方式？

 java DriverManager.registerDriver(new com.mysql.jdbc.Driver())//此处使用new一个类对象
修改成 
 Class.forName("com.mysql.jdbc.Driver");//此处只是一个字符串

原因是：
我们的类依赖了数据库的具体驱动类（MySQL），如果我们将mysql的驱动jar包删除，那么我们的程序是无法通过编译期的，所以这显然不是我们想要的。

3.解决程序耦合的思路

  1. 使用反射来创建对象，而避免使用new关键字；

在我们使用JDBC注册驱动的时候，是通过反射来注册驱动的，代码如下：
java Class.forName("com.mysql.jdbc.Driver");//此处只是一个字符串
这样的好处是: 我们的类中不再依赖具体的驱动类，此时就算删除 mysql 的驱动 jar
包，依然可以编译（但是无法运行，因为没有驱动）。

  1. 通过读取配置文件来获取要创建的对象全限定类名。

在我们上面的代码块中，MySql驱动的全限定名字符串被我们写死了，如果我们换其他的数据库就需要修改源码才能重新加载。在这个时候我们就可以通过读取配置文件的方式来获取要创建的对象的全限定类名。

4.工厂模式解耦

4.1.解耦思路

我们在开发中，有些依赖关系是必须的，有些依赖关系可以通过优化代码来解除的。

public class AccountServiceImpl implements IAccountService { 
    private IAccountDao accountDao = new AccountDaoImpl(); 
}

上面的代码表示： 业务层调用持久层，并且此时业务层在依赖持久层的接口和实现类。如果此时没有持久层实现类，编译将不能通过。这种编译期依赖关系，应该在我们开发中杜绝。我们需要优化代码解决。
在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。
那么，这个读取配置文件，创建和获取三层对象的类就是工厂。

4.2.多例解耦的具体实现

  1. 在resource目录下创建一个配置文件bean.properties来配置我们的service和dao，配置文件可以是xml也可以是properties，配置的内容：唯一标识=全限定类名（key=value)。
accountService = com.smallbeef.service.impl.AccountServiceImpl; 
accountDao = com.smallbeef.service.impl.AccountDaoImpl;
  1. 创建工厂
// 一个创建Bean对象的工厂
public class BeanFactory{
 //定义一个properties对象
 private static Properties props;
 //使用静态代码块为Properties对象赋值
 static{
     //实例化对象
     props = new Properties();
     //获取properties文件的流对象
     InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
     try {
         props.load(in);
     } catch (IOException e) {
         e.printStackTrace();
     }
 }

 /**
 1. 根据Bean的名称获取bean对象
 2. @param beanName
 3. @return
  */
 public static Object getBean(String beanName){
     Object bean = null;
     String beanPath = props.getProperty(beanName);
     try {
         // 通过反射new一个对象
         //newInstance每次都会调用默认构造函数创建对象
         bean = Class.forName(beanPath).newInstance();
     } catch (InstantiationException e) {
         e.printStackTrace();
     } catch (IllegalAccessException e) {
         e.printStackTrace();
     } catch (ClassNotFoundException e) {
         e.printStackTrace();
     }
     return bean;
 }
}
  1. 修改Client类中创建对象的方式
public class Client {
  	public static void main(String[] args) {
 //        IAccountService as = new AccountServiceImpl();
      	IAccountService as = (IAccountService) BeanFactory.getBean("accountService");
      	as.saveAccount();
  	}
  }
  1. 在servise层中解耦dao对象。
public class AccountServiceImpl implements IAccountService {

//    private IAccountDao accountDao = new AccountDaoImpl();
	 private IAccountDao accountDao = (IAccountDao) BeanFactory.getBean("accountDao");

	 public void  saveAccount(){
    	 accountDao.saveAccount();
 	}
}

此时，我们在运行Client类中的主方法，会发现当我们没有ServiceImpl或者DaoImpl 类时程序在编译期时不会报错

4.3.单例的解耦

我们只需要修改BeanFactory工厂类，代码如下：

// 一个创建Bean对象的工厂
public class BeanFactory{
    
    //定义一个properties对象
    private static Properties props;
    
    // 定义一个Map,用于存放我们要创建的对象，我们把它称之为容器
   	private static Map<String, Object> beans;
    
    //使用静态代码块为Properties对象赋值
    static{
        //实例化对象
        props = new Properties();
        //获取properties文件的流对象
        InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
        try {
            props.load(in);
            
            //实例化容器
            beans = new HashMap<String,Object>();
            //取出配置文件中所有的key
            Enumeration keys = props.keys();
            //遍历枚举
            while(keys.hasMoreElements()){
                //取出每个key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key,value);
                
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
	 /**
     * 根据Bean的名称获取对象 单例
     * @param beanName
     * @return
     */
     public static Object getBean(String beanName){
         return beans.get(beanName);
     }
    
    /**
     * 根据Bean的名称获取bean对象 多例
     * @param beanName
     * @return
     */
//    public static Object getBean(String beanName){
//        Object bean = null;
//        String beanPath = props.getProperty(beanName);
//        try {
//            // 通过反射new一个对象
//            //newInstance每次都会调用默认构造函数创建对象
//            bean = Class.forName(beanPath).newInstance();
//        } catch (InstantiationException e) {
//            e.printStackTrace();
//        } catch (IllegalAccessException e) {
//            e.printStackTrace();
//        } catch (ClassNotFoundException e) {
//            e.printStackTrace();
//        }
//        return bean;
//    }
}

5.IOC的概念

控制反转（Inversion of Control，缩写为IoC）实际上就是指对一个对象控制权的转换。是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。

  1. 在使用工厂方法之前，我们在获取对象时，都是采用new的方式，是主动的。
  2. 现在我们获取对象时，同时跟工厂（容器）获取，有工厂为我们查找或者创建对象，是被动的。
    这种被动接收的方式（由主动变被动）获取对象的思想就是控制反转，它是spring框架的核心之一。ioc的作用： 削减计算机程序的耦合(解除我们代码中的依赖关系)。

三、使用springIoC解决程序耦合

1.案例

1.1.建立maven工程，创建业务层接口和实现类

/**
* 账户的业务层接口
*/
public interface IAccountService {
   /**
   * 保存账户（此处只是模拟，并不是真的要保存）
   */
   void saveAccount();
}

/**
* 账户的业务层实现类
*/
public class AccountServiceImpl implements IAccountService {
  
   private IAccountDao accountDao = new AccountDaoImpl();// 此处的依赖关系有待解决
  
   @Override
   public void saveAccount() {
        accountDao.saveAccount();
   }
}

1.2.创建持久层接口和实现类

/**
* 账户的持久层接口
*/
public interface IAccountDao {
   /**
   * 保存账户
   */
   void saveAccount();
}

/**
* 账户的持久层实现类
*/
public class AccountDaoImpl implements IAccountDao {

    @Override
     public void saveAccount() {
       System.out.println("保存了账户");
     }
}

1.3. 在pom.xml文件中引入Spring相关依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
    </dependencies>

1.4. 创建bean.xml并导入约束(头部约束路径见下)

/spring-framework-5.0.2.RELEASE-docs/spring-framework reference/html5/core.html

 <?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
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--把对象创建交给spring来管理,spring会自动解析-->
    <bean id = "accountService" class = "com.smallbeef.service.impl.AccountServiceImpl"></bean>
    <bean id = "accountDao" class = "com.smallbeef.dao.impl.AccountDaoImpl"></bean>
</beans>

1.5. 在配置文件中配置service和dao

<!-- bean 标签：用于配置让 spring 创建对象，并且存入 ioc 容器之中
id 属性：对象的唯一标识。
class 属性：指定要创建对象的全限定类名
-->
<!-- 配置 service -->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
</bean>
<!-- 配置 dao -->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"></bean>

1.6.测试配置是否成功

public class Client {
/**
 * 模拟一个表现层，用于调用业务层
 */

public class Client {


    /**
     * 获取spring的IOC核心容器，并根据id获取对象
     * @param args
     */
    public static void main(String[] args) {
        //1.获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据ID获取Bean对象
          IAccountService as =(IAccountService) ac.getBean("accountService");
          IAccountDao adao = ac.getBean("accountDao",IAccountDao.class);

        System.out.println(as);
        System.out.println(adao);
    }
}

运行结果：运行结果

2.Spring基于XML的IOC

类结构图
在这里插入图片描述

3. ApplicationContext中常用的三个实现类：

  1. ClassPathXmlApplicationContext:它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了。（常用）；
  2. FileSystemXmlApplicationContext：它可以加在磁盘任意路径下的配置文件（必须有访问权限）；
  3. AnnotationConfigApplicationContext：它可以用于读取注解创建容器的。

4.核心容器的两个接口(BeanFactory和ApplicationContext)

  1. ApplicationContext：它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取晚配置文件马上就创建配置文件中配置的对象。适用于单例对象，在我们实际开发过程中大多采用此接口
  2. BeanFactory：它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式，也就是说，啥时候根据ID获取对象，啥时候就真正的创建对象。适用于多例对象。

5.BeanFactory和ApplicationContext的区别

  1. BeanFactory 是 Spring 容器中的顶层接口，而ApplicationContext是BeanFactory的子接口；
  2. 两者创建对象的时间点不同；

四、IOC中bean标签和管理对象细节

1.实例化Bean的三种方式

  1. 使用默认无参构造函数
 <!--在默认情况下：它会根据默认无参构造函数来创建类对象。如果 bean 中没有默认无参构造函数，将会创建失败。->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"/>
  1. spring 管理静态工厂- 使用静态工厂的方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器）
 /**
* 模拟一个静态工厂，创建业务层实现类
*/
public class StaticFactory {
   public static IAccountService createAccountService(){
       return new AccountServiceImpl();
  }
}

bean.xml中的配置代码如下：

id 属性：指定 bean 的 id，用于从容器中获取
class 属性：指定静态工厂的全限定类名
factory-method 属性：指定生产对象的静态方法
<bean id="accountService" class="com.itheima.factory.StaticFactory" factory-method="createAccountService"></bean>

这种方式使用 StaticFactory 类中的静态方法 createAccountService 创建对象，并存入 spring 容器。

  1. spring 管理实例工厂- 使用实例工厂的方法创建对象使用（某个类中的方法创建对象，并存入spring容器）
/**
* 模拟一个实例工厂，创建业务层实现类
* 此工厂创建对象，必须现有工厂实例对象，再调用方法
*/
public class InstanceFactory {
  public IAccountService createAccountService(){
     return new AccountServiceImpl();
  }
}

factory-bean 属性：用于指定实例工厂 bean 的 id。
factory-method 属性：用于指定实例工厂中创建对象的方法。
<bean id="instancFactory" class="com.itheima.factory.InstanceFactory"></bean>
<bean id="accountService"
factory-bean="instancFactory"
factory-method="createAccountService"></bean>

这种方式是：
先把工厂的创建交给 spring 来管理。
然后在使用工厂的 bean 来调用里面的方法。

2.Bean标签的作用和它的属性

  • 作用：
    用于配置对象让 spring 来创建的。
    默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
  • 属性：
  • id：给对象在容器中提供一个唯一标识。用于获取对象。
  • class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
  • scope：指定对象的作用范围。
  • singleton :默认值，单例的.
  • prototype :多例的.
  • request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
  • session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
  • global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么
  • globalSession 相当于 session
  • init-method：指定类中的初始化方法名称。
  • destroy-method：指定类中销毁方法名称。

3.Bean的作用范围以及生命周期

  1. Bean的作用范围

单例对象：scope="singleton"
一个应用只有一个对象的实例。它的作用范围就是整个引用。

多例对象：scope="prototype"
每次访问对象时，都会重新创建对象实例。

  1. Bean的生命周期

单例对象：scope="singleton"
生命周期：单例对象的生命周期和容器相同
对象出生：当应用加载，创建容器时，对象就被创建了。
对象活着：只要容器在，对象一直活着。
对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

多例对象：scope="prototype"
生命周期：
对象出生：当使用对象时，创建新的对象实例。
对象活着：只要对象在使用中，就一直活着。
对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

五、依赖注入

1.依赖注入的概念

  • 依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。
    我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况；
  • ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法；
  • 那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取；
  • 依赖关系的维护：就称之为依赖注入。

2.依赖注入可以注入哪些数据？可以注入的方式有哪些？

  1. 可以注入的数据有三类：
  • 基本类型和String；
  • 其他bean类型（在配置文件中或者注解配置过的bean)；
  • 复杂类型/集合类型；
  1. 注入的方式有三种：
  • 使用构造函数注入；
  • 使用set方法注入；
  • 使用p名称空间注入数据(本质还是调用set方法)。

3.构造函数注入

使用类中的构造函数，给成员变量赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让 spring 框架来为我们注入。具体代码如下：
Java 类代码如下：

/**
*/
public class AccountServiceImpl implements IAccountService {
       private String name;
       private Integer age;
       private Date birthday;
   
   public AccountServiceImpl(String name, Integer age, Date birthday) {
       this.name = name;
      this.age = age;
      this.birthday = birthday;
   }
    
  @Override
  public void saveAccount() {
      System.out.println(name+","+age+","+birthday);
  }
}

bean.xml配置代码如下：

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<constructor-arg name="name" value=" 张三 "></constructor-arg>
<constructor-arg name="age" value="18"></constructor-arg>
<constructor-arg name="birthday" ref="now"></constructor-arg>
</bean>
<bean id="now" class="java.util.Date"></bean>

使用构造函数的方式，给 service 中的属性传值

要求：

  • 类中需要提供一个对应参数列表的构造函数。

涉及的标签：

  • constructor-arg (Bean标签内部)

属性：

  • index:指定参数在构造函数参数列表的索引位置
  • type:指定参数在构造函数中的数据类型
  • name:指定参数在构造函数中的名称 用这个找给谁赋值

上面三个都是找给谁赋值，下面两个指的是赋什么值的

  • value:它能赋的值是基本数据类型和 String 类型
  • ref:它能赋的值是其他 bean 类型，也就是说，必须得是在配置文件中配置过的 bean

4.set方式注入

顾名思义，就是在类中提供需要注入成员的 set 方法。具体代码如下：
Java 类代码如下：

/** */
public class AccountServiceImpl implements IAccountService {
      private String name;
      private Integer age;
      private Date birthday;
   
    public void setName(String name) {
      this.name = name;
    }
   public void setAge(Integer age) {
     this.age = age;
   }
   public void setBirthday(Date birthday) {
     this.birthday = birthday;
   }

   @Override
   public void saveAccount() {
     System.out.println(name+","+age+","+birthday);
   }
}

bean.xml配置代码如下：

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<property name="name" value="test"></property>
<property name="age" value="21"></property>
<property name="birthday" ref="now"></property>
</bean>
<bean id="now" class="java.util.Date"></bean>

通过配置文件给 bean 中的属性传值：使用 set 方法的方式
涉及的标签：property
属性：
name：找的是类中 set 方法后面的部分
ref：给属性赋值是其他 bean 类型的
value：给属性赋值是基本数据类型和 string 类型的
实际开发中，此种方式用的较多。

5.使用p名称空间注入数据（本质还是调用set方法）

此种方式是通过在 xml中导入 p名称空间，使用 p:propertyName 来注入数据，它的本质仍然是调用类中的set 方法实现注入功能。具体代码如下：
Java 类代码如下：

/**
* 使用 p 名称空间注入，本质还是调用类中的 set 方法
*/
public class AccountServiceImpl4 implements IAccountService {
       private String name;
       private Integer age;
       private Date birthday;
     
   public void setName(String name) {
      this.name = name;
  }
  public void setAge(Integer age) {
      this.age = age;
  }
  public void setBirthday(Date birthday) {
      this.birthday = birthday;
  }
      
  @Override
  public void saveAccount() {
     System.out.println(name+","+age+","+birthday);
  }
}

bean.xml配置文件代码如下：

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=" http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="accountService"
class="com.itheima.service.impl.AccountServiceImpl4"
p:name="test" p:age="21" p:birthday-ref="now"/>
</beans>

6.注入集合属性(本质也是调用set方法)

顾名思义，就是给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。

  • 用于给list结构集合注入数据的标签：list、array、set
  • 用于给Map结构集合注入数据的标签 : map、props
  • 结构相同，标签可以互换

我们这里介绍注入数组，List,Set,Map,Properties。
具体代码如下：
Java 类代码如下：

/***/
public class AccountServiceImpl implements IAccountService {
       private String[] myStrs;
       private List<String> myList;
       private Set<String> mySet;
       private Map<String,String> myMap;
       private Properties myProps;

   public void setMyStrs(String[] myStrs) {
      this.myStrs = myStrs;
  }
  public void setMyList(List<String> myList) {
      this.myList = myList;
  }
  public void setMySet(Set<String> mySet) {
      this.mySet = mySet;
  }
  public void setMyMap(Map<String, String> myMap) {
      this.myMap = myMap;
  }
  public void setMyProps(Properties myProps) {
      this.myProps = myProps;
  }

  @Override
  public void saveAccount() {
  System.out.println(Arrays.toString(myStrs));
  System.out.println(myList);
  System.out.println(mySet);
  System.out.println(myMap);
  System.out.println(myProps);
  }
}

beam.xml配置文件代码如下：

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<!-- 在注入集合数据时，只要结构相同，标签可以互换 -->

<!-- 给数组注入数据 -->
<property name="myStrs">
<set>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</set>
</property>

<!-- 注入 list 集合数据 -->
<property name="myList">
<array>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</array>
</property>

<!-- 注入 set 集合数据 -->
<property name="mySet">
<list>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</list>
</property>

<!-- 注入 Map 数据 -->
<property name="myMap">
<props>
<prop key="testA">aaa</prop>
<prop key="testB">bbb</prop>
</props>
</property>

<!-- 注入 properties 数据 -->
<property name="myProps">
<map>
<entry key="testA" value="aaa"></entry>
<entry key="testB">
<value>bbb</value>
</entry>
</map>
</property>

</bean>
韩雨泽_97
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring-boot-demo学习记录（三）-集成 spring-boot-starter-actuator 用于监控 spring-boot 的启动和运行状态
qq_31374621的博客
08-30 1083
Spring-boot-demo学习记录 目录 Spring-boot-demo学习记录 前言 一、demo是什么？ 二、使用步骤 1.新建子模块 2.代码编写 总结 前言 此系列博客是个人在学习springBoot的学习笔记，算是一个记录吧，一方面记录学习的内容，一方面记录学习中犯下的错误。学习springBoot选择的是GitHub上一个比较著名的项目，链接如下https://github.com/xkcoding/spring-boot-demo.git...
Spring学习笔记-cqupt
03-19
在本篇 Spring 学习笔记中，我们将探讨 Spring 的入门、优点、组成以及重要的IOC理论。 1. **Spring 简介** Spring 是一个开源的、免费的 Java 框架，它的目标是减少企业级开发的复杂性。它集成了许多现有的技术，...
Spring-尚硅谷-学习笔记
weixin_45581692的博客
10-10 6357
Spring框架是一个轻量级的开源的JavaEE框架。 Spring可以解决企业应用开发的复杂性。 Spring有两个核心部分：IOC和AOP IOC：控制反转，把创建对象的过程交给Spring AOP：面向切面，不修改源代码的情况下进行功能增强 Spring特点 方便解耦，简化开发 AOP编程支持 方便程序测试 方便和其他框架进行整合
Spring学习笔记----AOP编程
太匆匆
07-14 3477
先用代码讲一下什么是传统的AOP(面向切面编程)编程 需求：实现一个简单的计算器，在每一步的运算前添加日志。最传统的方式如下： Calculator.java package cn.limbo.spring.aop.calculator; /** * Created by Limbo on 16/7/14. */ public interface Calculator { in
Spring学习笔记--注解总结
qq_33105531的博客
12-23 1302
Spring学习笔记--注解总结（ -----------------------------持续更新------------------------------------ 注解总结： @Configuration 标识当前类是配置类 @ComponentScan 包扫描注解 扫描注解 @Bean 标识该方法的返回值交给Spring容器管理 @Scope 控制单例和多例 @Lazy 懒加载 @PostConstruct 初始化方法 @PreDestroy 销毁方法 @
spring框架--全面详解（学习笔记）
swy2560666141的博客
02-26 1万+
由 Spring IoC 容器管理的对象称为 Bean，Bean 根据 Spring 配置文件中的信息创建。可以把 Spring IoC 容器看作是一个大工厂，Bean 相当于工厂的产品，如果希望这个大工厂生产和管理 Bean，则需要告诉容器需要哪些 Bean，以及需要哪种方式装配 Bean。Spring 配置文件支持两种格式，即 XML 文件格式和 Properties 文件格式。
Spring源码学习---------(最简单易懂的源码学习笔记)
热门推荐
奇点
07-05 1万+
前沿 工作一段时间了，之前一直想学习一下spring的源码，最近有时间学习了一下。现在把最近学习的成果整理一下，也向大家分享一下。 下面是spring源码的学习笔记，仅供参考。本人能力有限，难免会出现问题，欢迎各位大佬指出。 读源码的方法： 之前只是看过JDK的一些源码，像是spring和springboot等源码只是简略的看过，并没有系统的学习过，同时，这么优秀的作品很是值得我们学习的。抱着好奇心开始了读spring源码的道路，废话不多说，这里把我的学习笔记分享给大家。 读源码首先找...
SpringCloud笔记-01-服务拆分
Timeless小帅的博客
04-16 950
服务拆分基本概念
SpringCloud学习笔记 - 1、Boot和Cloud版本选型
DarkAndGrey的博客
06-13 1562
本专栏文章的内容均来自于B站up主“尚硅谷”的教程视频。博主的博客，你可以理解为是博主在做笔记，方便复习。希望也可以帮到你们。
Spring Boot2 系列教程(三)理解 spring-boot-starter-parent
2401_84049061的博客
05-02 846
在清楚了各个大厂的面试重点之后，就能很好的提高你刷题以及面试准备的效率，接下来小编也为大家准备了最新的互联网大厂资料。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！[外链图片转存中…(img-H67vbRWV-1714657149485)]《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！
Spring Boot 学习笔记 6 : spring-boot-starter-mail
走马观花
04-13 2516
spring boot 学习笔记 : java mail
黑马程序员-SpringCloud-学习笔记01-认识微服务
06-18
黑马程序员-SpringCloud-学习笔记01-认识微服务
黑马程序员-SpringCloud-学习笔记-03-Eureka注册中心
06-18
黑马程序员-SpringCloud-学习笔记-03-Eureka注册中心
spring-framework-2.5.6.SEC01
05-08
《Spring Framework 2.5.6.SEC01：经典版本的深度剖析》 Spring Framework作为Java开发领域的重要支柱，自推出以来就以其强大的功能和灵活性赢得了广大开发者的心。2.5.6.SEC01是Spring的一个经典版本，包含了丰富...
spring-mvc-01.zip
05-18
在 "spring-mvc-01.zip" 文件中，我们可以预见到一系列与Spring MVC相关的教程或项目资源。这些资源可能包括源代码、配置文件、文档和示例应用，旨在帮助我们了解和掌握Spring MVC的核心概念和使用方法。 首先，让...
枚举工具类
qq_43049583的博客
08-04 222
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
最新发布
泰勒今天想展开的博客
08-04 286
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 619
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 565
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
Spring框架学习笔记：IoC与AOP解析
"Spring_in_action_学习笔记" Spring框架是Java开发中的一个重要组成部分，以其轻量级、非侵入式的设计理念赢得了广泛的认可。本学习笔记主要涵盖了Spring的基础知识，包括核心特性和模块组成。 1. Spring核心特性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值