【Spring学习笔记】Spring框架的IoC容器学习笔记

最新推荐文章于 2021-08-18 11:19:41 发布
最新推荐文章于 2021-08-18 11:19:41 发布
阅读量1.8k 收藏
点赞数 1
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/phil2036/article/details/8396016
版权

一、IoC容器概述

        IoC容器是一种面向接口编程，将接口的具体实现和对象的组装延后至编译后，并将这些配置从代码提取到配置文件中的一种编程方式。IoC容器通过JAVA提供的反射机制根据配置文件提供的信息选择实现类并装配实例化对象。

        IoC容器允许这样一种编程模式：首先定义一个接口，并且通过接口实现两个不同实现方式的实现类（比如对于存储数据这个接口，实现一个用操作系统文件方式存储的类和一个用数据库存储的类），然后某个业务类使用这个接口的实现来完成某项任务。在通常使用的编程模式中此时需要在业务类中创建接口的某个实现（即使用哪个实现类在代码中，并且在编译前必须决定），而IoC容器则将此过程延后，并将其提取到一个xml配置文件中（也可以使用注解的模式），如果在应用发布后需要修改某个接口的实现，只需要修改配置文件而无需对代码进行修改、重新编译和重新发布。

        IoC容器提供了这样的一种理念：按照清晰的功能模块来构造应用，用接口来描述模块功能，同个模块功能提供针对不同应用环境的不同实现，在部署时按照实际应用环境通过配置文件重新组装、优化应用。

二、IoC容器的基本底层实现

        IoC容器的底层实现主要依赖于JAVA的反射机制。通过反射机制和配置文件，容器载入相应的.class文件，实例化对象。使用java.reflect.Method类调用相应的set方法来设置对象属性。如下的配置文件：

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

	<bean 	name="car" class="com.sample.bean.Car" 
			p:companyName="Chevrolet"
			p:carName="Cruze"
			p:color="White"
			p:maxSpeed="190" 
			init-method="init"
			destroy-method="destory"></bean>

</beans>
1.容器通过某个XML解析器，解析配置文件；

2.在节点<bean>处，解析出class=com.sample.bean.Car属性，使用ClassLoader载入对应的.class文件，获得一个Class<Car>类型的对象；

3.通过Class<Car>.getDeclaredContructor成员函数获取Constructor<?>类型的对象，这里没有配置<constructor-arg>子节点，所以获取使用空参数的构造函数对象；

4.使用Constructor<?>.newInstance成员函数实例化com.sample.bean.Car对象；

5.解析p命名空间下的所有属性，并通过Class<Car>.getDeclaredMethod方法获取相应setXXX方法对应的Method对象，并且通过调用Method.invoke方法来实际执行Car.setXxx方法设置属性；

6.解析init-method属性，通过Class<Car>.getDeclaredMethod和属性的值来获得对应Car.init的Method对象，执行Method.invoke，实际效果为执行Car.init；

7.将生成完成的对象放入到IoC的Bean缓冲池中；

8.当IoC容器被释放时，通过解析destory-method属性，通过Class<Car>.getDeclaredMethod和属性的值来获得对应Car.destory的Method对象，执行Method.invoke，实际效果为执行Car.destory，完成相关资源的释放；

        通过以下代码即可获得配置文件中id为car的Car类实例对象，通过打印相关信息我们可以看到相应的属性已经被设置为配置文件中我们配置好的值。

public class MainEntry
{
	public static void main(String[] args)
	{
		ClassPathXmlApplicationContext actx = new ClassPathXmlApplicationContext("applicationContext.xml");
		Car car = (Car)actx.getBean("car");
		System.out.println(car);
		actx.close();
	}
}

三、相关XML文件概念

        在前面的配置文件中

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

	<bean 	name="car" class="com.sample.bean.Car" 
			p:companyName="Chevrolet"
			p:carName="Cruze"
			p:color="White"
			p:maxSpeed="190" 
			init-method="init"
			destroy-method="destory"></bean>

</beans>

在beans节点中，有xmlns和xsi:schemaLocation两个属性，这两个属性的语法意义如下文

1.xmlns 命名空间定义

        定义一个命名空间的语法为xmlns:namespace-prefix="namespaceURI"，例如以上xml文件中的xmlns:p="http://www.springframework.org/schema/p"。namespace-prefix是命名空间的缩写，而后面的namespaceURI是命名空间的全称。在后面使用命名空间时只需要在节点或者属性的名字前加上“namesapce-prefix:”即可。作为命名空间全称的namespaceURI在形式上虽然是一个URI，但是这只是命名空间名字的一种约定俗成的命名方法，并不作为查找schema的路径或其他任何用处，这样做的好处只是为了有效避免命名空间的名字冲突。xml当中命名空间的用处和C++的名字空间以及java的包的用处是相同的，即避免名字冲突的作用。

        在这里我们看到有一个命名空间的定义省略了namespace-prefix部分，即xmlns="http://www.springframework.org/schema/beans"，这定义了一个默认命名空间的名字，也就是说，下面不用省略namespace-prefix:nodeName标识的节点，如上面xml中的bean节点使用的是以上这个默认命名空间。

2.xsi:schemaLocation命名空间对应schema文件的URI

        这个属性定义了一个命名空间使用的schema文件路径，此属性告诉xml解析器当遇到命名空间时去哪里查找对应的schema文件。这里定义的格式为namespaceURI schemaFileURI。namespaceURI和schemaFileURI之间用空格、换行符隔开。

四、IoC容器的配置(XML和注解模式)

        Spring通过一个配置文件或者注解的方式来描述Bean(生命周期和属性值)和Bean之间的依赖关系，利用JAVA的反射机制实现Bean和Bean之间的依赖关系，并且通过BeanFactory或者ApplicationContext的实例将Bean提供给应用使用。

1.基本属性的配置

        基本属性是指JAVA中的基本数据类型，例如整型、浮点、字符等等。

a.XML配置

        在XML中我们使用p命名空间的属性来配置基本属性，配置的格式为p:<属性名>=值。实例如下

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

<bean 	name="car" class="com.sample.bean.xml.Car" 
			p:companyName="Chevrolet"
			p:carName="Cruze"
			p:color="White"
			p:maxSpeed="190" />

</beans>
       在这个XML配置文件的实例中p:companyName会由容器使用JAVA的反射机制自动调用Car.setCompanyName("Chevrolet")这个访问器函数来实现属性值的设置。注意在xmlns和xsi:schemaLocation当中对于p命名空间的设置。

2.引用属性的注入

        引用属性是指，一个类当中的一个字段需要应用类一个类的一个实例，例如下面的代码

public class Car
{
	private String	companyName;
	private String	carName;
	private String	color;
	private int		maxSpeed;
        
        //set/geter
}

public class Person
{
	private Car car;

        //set/geter
}
在类Person当中有一个引用了Car实例的引用属性，在对这种类型的配置时有两种配置方法：

a.xml配置方法

使用xml配置时，我们依旧使用p命名空间，只是格式与基本属性配置略有不同，我们使用p:<属性名>-ref，例如：

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

<bean 	name="car" class="com.sample.bean.xml.Car" 
			p:companyName="Chevrolet"
			p:carName="Cruze"
			p:color="White"
			p:maxSpeed="190" 
			init-method="init"
			destroy-method="destory"
			scope="prototype"></bean>
			
<bean 	name="person" class="com.sample.bean.annotation.Person"
			p:car-ref="car"/>

</beans>
b.使用annotation配置

        使用annotation配置Bean时，首先要通过一个注解告知容器某个类是一个Bean，用于告知容器某个类是一个Bean的注解一共有四个个：@Compoent、@Service、@Controller和@Repository。这四个注解从功能上讲完全一样，只是用来区分所标识的类在应用中所属的角色

         @Compoent：表示类在应用中属于领域角色，是组件类

         @Repository：表示类在应用中属于DAO层

         @Service：Service业务层的类

         @Controller：控制层的类

        在使用相应的注解标识完类为Bean以后就可以开始注入Bean属性的值了，默认情况下Spring利用类名来选择注入的引用实例，此时只需要使用@Autowired来标识属性即可。当对应的类在容器中配置有多个实例时需要配合使用@Qualifier和Bean的id属性来做限制。

        @Autowired中有一个可选的参数required。这个参数的作用是：当标注为Autowired的属性如果在容器中找不到相关的Bean时，如果设置为true时则抛出异常，否则设置为null。

        @Autowired可以设置在属性声明上，也可以设置在set访问器函数上。具体实例如下

@Component
@Scope(value="singleton")
public class Person
{
	@Autowired(required=false)
	@Qualifier("car")
	private Car car;
}

        在使用annotation进行属性注入时，我们需要在主配置文件中通过<context:component-scan>来告知Spring容器去哪里扫描那些被注解配置为Bean的类

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

<context:component-scan base-package="com.sample.bean.annotation"></context:component-scan>

</beans>
3.容器属性的配置

a.xml配置

List容器：

<bean id="person" class="com.sample.Person">
	<property name="favorites">
		<list>
			<value>shopping</value>
			<value>music</value>
		</list>
	</property>
</bean>
Set容器 

<bean id="person" class="com.sample.Person">
	<property name="favorites">
		<set>
			<value>shopping</value>
			<value>music</value>
		</set>
	</property>
</bean>
Map容器 

<bean id="person" class="com.sample.Configure">
	<property name="path">
		<map>
			<entry>
				<key><value>JAVAHOME</value></key>
				<value>jcommon</value>
			</entry>
			<entry>
				<key><value>ACE</value></key>
				<value>common</value>
			</entry>
		</map>
	</property>
</bean>
Property容器，该容器与Map容器相同，区别只是在该容器当中key必须为字符串，配置时也与Map容器完全相同，只需要把节点名字<map>改成<prop>即可

b.使用annotation配置

使用annotation来配置集合类时，依旧使用@Autowired注解，注解的使用方式与配置引用属性时完全相同，需要注意的是，凡是容器模板参数中类型参数T的类型实例以及子类的实例均会被配置进容器中。

4.初始化和销毁方法

        Bean的初始化方法在Bean被创建并配置完所有属性后被调用，用于进行一些初始化操作，而销毁方法只会在Bean被配置为singleton生命周期时才会发生，他发生在Spring容器被销毁，Bean缓存清空时，他用于资源的回收和释放。

        配置这两个方法在xml中使用<init-method>和<destory-method>对应可以使用@PostConstruct和@PreDestory两个注解来配置。

5.继承

        在使用XML文件进行配置时，一个类可以被配置为多个id的实例，在这些实例中有些公共的属性会是相同的，因此，我们可以使用类似类继承的关系来描述这些Bean。要使用这个功能只需要在子Bean当中使用parent属性标识父Bean即可，子Bean可以覆盖父Bean当中属性的设置。另外，如果一个Bean要被设置为纯虚的父Bean的话只需要设置属性abstract="true"即可，这样他只能被继承而不能在应用中获取此Bean的实例。

6.依赖

        当一个类的创建、初始化依赖于另一个类的存在时，即当获取这个类的实例的实例时，另一个类的实例必须首先已经存在。此时依赖的类可以通过设置depends-on="beanId"即可，Spring容器保证在创建该Bean之前先创建id为beanId的Bean。

五、Bean的生命周期

        Spring当中的Bean生命周期可以用下面的图示来描述


1．当调用者通过getBean(beanName)向容器请求某一个Bean 时，如果容器注册org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor 接口，在实例化Bean 之前，将调用接口的postProcessBeforeInstantiation()方法；
2．根据配置情况调用Bean 构造函数或工厂方法实例化Bean；
3．如果容器注册了InstantiationAwareBeanPostProcessor 接口，在实例化Bean 之后，调用该接口的postProcessAfterInstantiation()方法，可在这里对已经实例化的对象进行一些“梳妆打扮”；
4．如果Bean 配置了属性信息，容器在这一步着手将配置值设置到Bean 对应的属性中，不过在设置每个属性之前将先调用InstantiationAwareBeanPostProcessor 接口的
postProcessPropertyValues()方法；
5．调用Bean 的属性设置方法设置属性值；
6．如果Bean 实现了org.springframework.beans.factory.BeanNameAware 接口，将调用setBeanName()接口方法，将配置文件中该Bean 对应的名称设置到Bean 中；
7．如果Bean 实现了org.springframework.beans.factory.BeanFactoryAware 接口，将调用 setBeanFactory()接口方法，将BeanFactory 容器实例设置到Bean 中；
8．如果BeanFactory 装配了org.springframework.beans.factory.config.BeanPostProcessor后处理器，将调用BeanPostProcessor 的Object postProcessBeforeInitialization(Object bean,String beanName)接口方法对Bean 进行加工操作。其中入参bean 是当前正在处理的Bean，而beanName 是当前Bean 的配置名，返回的对象为加工处理后的Bean。用户可以使用该方法对某些Bean 进行特殊的处理，甚至改变Bean 的行为，BeanPostProcessor 在Spring 框架中占有重要的地位，为容器提供对Bean 进行后续加工处理的切入点，Spring 容器所提供的各种“神奇功能”（如AOP，动态代理等）都通过BeanPostProcessor 实施；
9．如果Bean 实现了InitializingBean 的接口，将调用接口的afterPropertiesSet()方法；
10．如果在<bean>通过init-method 属性定义了初始化方法，将执行这个方法；
11．BeanPostProcessor 后处理器定义了两个方法：其一是postProcessBeforeInitialization()在第8 步调用；其二是Object postProcessAfterInitialization(Object bean, String beanName)方法，这个方法在此时调用，容器再次获得对Bean 进行加工处理的机会；
12．如果在<bean>中指定Bean 的作用范围为scope=“prototype”，将Bean 返回给调用者，调用者负责Bean 后续生命的管理，Spring 不再管理这个Bean 的生命周期。如果作用范围设置为scope=“singleton”，则将Bean 放入到Spring IoC 容器的缓存池中，并将Bean引用返回给调用者，Spring 继续对这些Bean 进行后续的生命管理；
13．对于scope=“singleton”的Bean，当容器关闭时，将触发Spring 对Bean 的后续生命周期的管理工作，首先如果Bean 实现了DisposableBean 接口，则将调用接口的
afterPropertiesSet()方法，可以在此编写释放资源、记录日志等操作；
14．对于scope=“singleton”的Bean，如果通过<bean>的destroy-method 属性指定了Bean的销毁方法，Spring 将执行Bean 的这个方法，完成Bean 资源的释放等操作。

六、使用属性文件配置IoC容器

        当我们使用一个Bean来保存连接数据库的相关信息时，我们会在配置的xml文件中写入jdbc驱动和相关的连接URI，当实际部署应用时很有可能因为实际数据服务器部署方式的不同需要修改这个配置文件。因为IoC容器的配置文件往往会根据模块分散在各个包的路径下，此时会给项目实施人员带来诸多不便。此时较好的解决方案是在一个特定的位置使用一个属性文件来配置这些信息，然后在IoC的配置文件中指定属性文件的扫描位置，然后使用属性来装配IoC容器中的Bean。使用属性文件的实际的IoC容器配置文件如下：

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

 
	<context:property-placeholder location="classpath:properties/global.properties" file-encoding="utf-8"/>
 	
	<bean id="globalConfig" class="com.baobaotao.global.DataSource"
	p:name="${db.name}"
	p:url="${db.jdbcUrl}" />
	
</beans>
1.使用节点<context:property-placeholder>来指定属性文件的位置，location属性指定了属性文件的路径，file-encoding指定了属性文件的编码格式。这里需要导入context名字空间。

2.在装配bean的属性时，使用${propertyName}的方式来引用属性。特别需要注意的时，需要保留""的使用

七、IoC容器的i18n(国际化)配置

        国际化就是使应用的一些字符根据应用所部属的计算机所属位置显示相应的语言。要确定一个国际化信息需要两个信息：语言信息和地区信息，语言信息根据ISO-639标准确定，地区信息根据ISO-3166标准确定。在Spring当中分别使用两组字母来确定国际化信息，通常是在属性文件名的最后加上后缀"-语言信息-地区信息"，比如一个属性文件名字为global.properties，那么表示简体中文的属性文件会被命名为global-zh-CN.properties，台湾繁体中文会被命名为global-zh-TW.properties。

        要在Spring中使用国际化配置的功能，首先要按照国际化信息编写对应的properties文件。例如，我们要支持简体中文和英文两种国际化信息就需要配置以下的两个properties文件，并放在同一个路径下：

//global-en-US.properties
label="Welcome to use spring"
//global-zh-CN.properties
label="欢迎使用Spring"

        特别需要注意的是，非英文的配置文件中的字符必须使用UTF-8转义码的格式来进行保存，我在这里使用了MyEclipse的转码插件

        然后，在配置文件中增加对于org.springframework.context.support.ReloadableResourceBundleMessageSource类的装配信息

<bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
 		<property name="basenames">
 			<list>
 				<value>properties/global</value>
 			</list>
 		</property>
 	</bean>
       这个Bean的id必须为messageSource。在属性的basenames中使用一个<list>数组来配置，这里的值为包含国际化信息的属性文件路径前缀，即不包含语言信息、地区信息后缀的属性文件路径。

       最后是使用这些国际化信息配置过的值，这里需要使用ApplicationContext.getMessage方法，具体代码如下

public static void main(String[] args)
{
	ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
	System.out.println(ctx.getMessage("label",null,Locale.CHINA));
}
ApplicationContext.getMessage的第一个参数为国际化属性文件中的键名字，第三个参数是一个用Locale表示的国际化位置信息。

八、IoC容器事件

        Ioc容器的事件系统与其他框架的事件系统构成基本相同，事件系统由事件、监听器和发送者三者构成。

        作为IoC容器的事件，必须从ApplicationEvent继承，并且重写构造函数（构造函数的第一个参数，也是基类构造函数的唯一参数标识了事件的发送者），同时重写一些相应数据的get/set方法

public class BuyCarEvent extends ApplicationEvent
{
	private Car	car;
	
	public BuyCarEvent(Boss boss,Car car)
	{
		super(boss);
		this.car = car;
	}
	
	public Car getCar()
	{
		return car;
	}
}
         作为监听器，必须实现ApplicationEvent<T>接口，同时实现onApplicationEvent(T event)方法，从而实现对事件的处理 

public class BuyCarListener implements ApplicationListener<BuyCarEvent>
{
	@Override
	public void onApplicationEvent(BuyCarEvent event)
	{
		Boss boss = (Boss)event.getSource();
		Car car = event.getCar();
		System.out.println(boss.getName() + " buy a car" + car);
	}
	
}
         作为事件的发送者必须继承自ApplicationContextAware，通过实现setApplicationContext方法来获取容器使用的ApplicationContext对象，同时使用这个对象来发出事件 

public class Boss implements ApplicationContextAware
{
	private String 	name;
	private Car		car;
	private ApplicationContext ctx;
	
	public Boss()
	{
		super();
		// TODO Auto-generated constructor stub
	}
	
	public void BuyCar()
	{
		ctx.publishEvent(new BuyCarEvent(this,car));
	}

	public String getName()
	{
		return name;
	}

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

	public Car getCar()
	{
		return car;
	}

	public void setCar(Car car)
	{
		this.car = car;
	}
	
	@Override
	public String toString()
	{
		String str = "Boss[" + name + "," + car + "]";
		return str;
	}

	@Override
	public void setApplicationContext(ApplicationContext applicationContext)
			throws BeansException
	{
		ctx = applicationContext;
	}
}


phil2036
关注
专栏目录
Spring框架实现之IoC容器
jingnie1959的博客
05-28 452
IoC自定义容器实现IoC容器简单实现什么是IoC容器功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 IoC容器简单实现 什么是IoC容器 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器
Spring笔记（3）：IOC容器
Zain_horse的博客
03-06 696
Spring笔记（3）：IOC容器
Spring及IOC容器学习笔记！
m0_48847163的博客
05-23 170
spring是什么？ 简单来说，spring是一个轻量级的开源的javaEE框架，用来解决企业开发过程中的复杂性。spring有两个核心：IOC和AOP。 IOC：控制反转：把创建对象的过程以及调用的过程交给spring管理。 AOP：面向切面：不修改源代码的情况下进行功能增强。 spring特点： ①：方便解耦，简化开发 ②：Aop编程支持 ③：方便程序测试 ④：方便与其他框架结合 ⑤：方便事务操作 ⑥：降低API开发的难度 初次使用步骤： ①：加载配置文件。 ②：获取配置创建的对象。 IOC容器
【Spring】理解Spring IOC容器
heyong的博客
08-18 241
一、概述 IOC中文名为控制反转，这里的反转指的是依赖对象的获得被反转了。为了更明确说明控制反转的含义，我举了一个简单的例子，如下： 假设有一个对象A依赖于对象B： class A{ //A依赖B private B b; //构造函数 public A(B b){ this.b = b; } //setter public void setB(B b){ this.b = b; } } class B{ //类B } 不使用IOC时：当类A依赖类B时，我们首先要先实例化对象
spring5学习笔记（IOC容器）
RonaldMH的博客
06-02 145
Spring5 框架概述 1、Spring 是轻量级的开源的 JavaEE 框架 2、Spring 可以解决企业应用开发的复杂性 3、Spring 有两个核心部分：IOC 和 Aop （1）IOC：控制反转，把创建对象过程交给 Spring 进行管理 （2）Aop：面向切面，不修改源代码进行功能增强 4、Spring 特点 （1）方便解耦，简化开发 （2）Aop 编程支持 （3）方便程序测试 （4）方便和其他框架进行整合 （5）方便进行事务操作 （6）降低 API 开发难度 ...
轻量级框架Spring学习笔记
01-25
Spring框架是Java开发中广泛应用的一个轻量级框架，它的核心特性包括依赖注入（Dependency Injection，简称DI）和控制反转（Inversion of Control，简称IOC）。本文将深入探讨这些概念以及Spring框架的其他重要模块...
Spring学习笔记1之IOC详解尽量使用注解以及java代码
09-02
在传统的编程模式中，对象通常自行创建它们所依赖的对象，而在IOC中，这种控制权被反转，由外部容器（如Spring框架）负责管理对象的生命周期和依赖关系。这样，对象只需要声明其依赖，而无需知道如何实例化或获取...
spring学习笔记共10页.pdf.zip
11-25
这份"spring学习笔记共10页.pdf.zip"压缩包文件，显然包含了关于Spring框架的详细学习资料，可能是由一位经验丰富的开发者或教师精心整理的。在10页的笔记中，我们可以期待涵盖Spring框架的基础概念、核心特性以及...
Java Spring框架学习笔记（内附源码）.pdf
04-09
在本次的Java Spring框架学习笔记中，将对Spring框架的核心概念进行详细解析，包括Spring的 IOC（控制反转）、AOP（面向切面编程）、jdbcTemplate、事务管理、Spring5新特性以及与Mybatis的整合。本学习笔记提供了...
javaSpring学习笔记
最新发布
03-12
在“Java Spring学习笔记”中，你将找到对Spring框架的全面介绍，包括IoC（控制反转）和DI（依赖注入）原理、AOP（面向切面编程）、Spring MVC、Spring Boot等核心内容。每个主题都结合了理论知识和实际示例，帮助你...
J2EE中文乱码的解决方案
Phil.Z's Program Blog
09-12 3197
转贴为主，中间夹一部分评论（红色的） 原帖地址：http://wanglei8.javaeye.com/blog/265770使用的构建平台：Tomcat5.5+JDK1.5+Eclipse3.4.11.数据库建立为UTF-8格式 2.项目右键属性为UTF-8格式 3.所有页面申明为UTF-8 4.JDBC URL设为：UTF-8 jdbc:mysql://localhost:33
【Spring学习笔记】AOP编程学习笔记
Phil.Z's Program Blog
12-30 1164
一、AOP编程使用的场合         我们在使用Hibernate或者JDBC进行数据库编程的时候，通常在业务层会遇到这样的代码：获取session、打开事物、按业务逻辑执行DAO对象访问，捕获异常回滚操作或者无异常提交操作、关闭事物、关闭session。几乎在每个业务逻辑处理时都会进行类似顺序的处理，而这些代码是重复的并且是无法通过继承关系来进行代码复用，虽然使用模板模式可以进行一定程度的
JAVA自学笔记(二)：类生存周期及访问权限
Phil.Z's Program Blog
07-26 1001
      这个部分的笔记对应Thinking in JAVA 3rd的第四章和第五章（P140-P202）。这部分的主要内容是类的创建和销毁过程及数据访问权限 一、对象的创建       在第一部分的笔记当中提到过JAVA当中的类对象只能通过new在堆上创建。这部分关心的主要议题是，创建时刻各种类数据成员（JAVA当中应该称之为域）的初始化过程。       JAVA有别于C++
JAVA自学笔记(六) JAVAIO
Phil.Z's Program Blog
08-09 937
      这部分对应Thinking in JAVA 3rd的P488-P585，这部分的内容在Thinking in JAVA这本书上写得很难看懂，于是搜罗了google上的几篇文章，这里转载这两篇文章。 出处：http://hzxdark.javaeye.com/blog/40133这篇文章主要介绍了decorator设计模式，这是JAVAIO的基础我不知道各位是师弟师妹们学
JAVA自学笔记(三)接口与内部类
Phil.Z's Program Blog
07-30 857
      这个部分对应Thinking in JAVA 3rd P264-P312。这个部分当中的接口还算好理解，但是内部类书上写了好多特殊用法，很繁杂，没有仔细研究，准备以后用到的时候再去研究他。      这个部分对于C++而言可以说是全新的，当然有些概念是C++当中用过的，但是JAVA用了一种更加简洁的方式来实现。接口和内部类说到底是为了解决CPP当中多继承所带来的一些问题，这些问题主
JAVA自学笔记(二)：重用与多态
Phil.Z's Program Blog
07-28 825
      这部分内容对应Thinking in JAVA 3rd P202-P264，我手上的是EBOOK不得不说这部分的翻译是比较烂的，不知道纸质版会不会好一点。特别指出一点，书上的一些称为重载的地方应该是重写，重载这个术语的意义并不是这本书上所写的，具体可以参考任何一本C/C++的书。      这部分其实较C++而言并没有太多不同的东西，一些不同的东西大多书还是存在在一些关键字上面。
JAVA自学笔记(一)：基础
Phil.Z's Program Blog
07-22 810
这些JAVA学习笔记的重点将在比较C++和JAVA的一些不同，但不会区分谁优谁劣。这些笔记是在我看Thinking in JAVA这本书时写的，我虽然很熟悉C/C++但是对于JAVA有一些概念但仍然是一个新手。 这个部分的笔记针对的是Thinking in JAVA 3rd p65-p140的一些东西。 一、变量     C/C++当中我认为变量可以分为三大类：基本的变量、指针
JAVA自学笔记(四)异常
Phil.Z's Program Blog
08-01 571
Thinking in JAVA 3rd P312-P352       JAVA的异常可以认为是一种更加严格的C++异常进化。      JAVA的异常类都继承自Throwable类。JAVA的所有方法如果要使用异常（抛出异常）则必须要在方法声明上加上一个异常规范（throws加上异常类列表），这个异常规范规定的异常类范围必须大于等于方法所要抛出的异常类范围。如果类处于继承链当中，那
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、付费专栏及课程。

余额充值