学习笔记之Spring框架

最新推荐文章于 2024-04-26 20:19:53 发布

2YSP

最新推荐文章于 2024-04-26 20:19:53 发布

阅读量479

点赞数

分类专栏：开发框架文章标签： spring 框架配置文件

本文链接：https://blog.csdn.net/stupid_java_learner/article/details/51959839

版权

开发框架专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1.Spring框架的作用：

简单来说，Spring主要就是用来处理dao层，service层以及action层的对象的创建以及对象的依赖关系。

2.专业术语

组件/框架设计：

侵入式设计

引入了框架，对现有的类的结构有影响；即需要实现或继承某些特定类。

例如： Struts框架

非侵入式设计

引入了框架，但对现有的类结构没有影响，例如： Hiernate框架和Spring框架

控制反转：

Inversion on Control,控制反转IOC,对象的创建交给外部容器完成，这个就叫做控制反转。

依赖注入：

dependency injection,处理对象的依赖。

二者区别：

控制反转是解决对象创建的问题【对象的创建交给别人】，

依赖注入，是在创建完对象后，对象关系的处理就是依赖注入【通过set方法注入】

AOP

面向切面编程，所谓切面，可以理解为一个类，由很多重复代码形成的类。

切面举例：事务，日志，权限。

3.概述

Spring框架提供了一站式解决方案：

1） Spring Core spring的核心功能： IOC容器, 解决对象创建及依赖关系

2） SpringWeb Spring对web模块的支持。

-> 可以与struts整合,让struts的action创建交给spring

-> spring mvc模式

3） Spring DAO Spring 对jdbc操作的支持【JdbcTemplate模板工具类】

4） SpringORM spring对orm的支持：

-> 既可以与hibernate整合，【session】

->也可以使用spring的对hibernate操作的封装

5）Spring AOP 切面编程

6）SpringEE spring 对javaEE其他模块的支持

开发步骤

1.引入jar包

2.写配置文件

核心配置文件: applicationContext.xml

Spring配置文件：applicationContext.xml/ bean.xml

约束参考：

spring-framework-3.2.5.RELEASE\docs\spring-framework-reference\htmlsingle\index.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" 
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
    	 http://www.springframework.org/schema/beans/spring-beans.xsd
     	 http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
     	 http://www.springframework.org/schema/tx/spring-tx.xsd">

3.API

public class App {

	// 1. 通过工厂类得到IOC容器创建的对象
	@Test
	public void testIOC() throws Exception {
		// 创建对象
		// User user = new User();
		
		// 现在，把对象的创建交给spring的IOC容器
		Resource resource = new ClassPathResource("cn/itcast/a_hello/applicationContext.xml");
		// 创建容器对象(Bean的工厂), IOC容器 = 工厂类 + applicationContext.xml
		BeanFactory factory = new XmlBeanFactory(resource);
		// 得到容器创建的对象
		User user = (User) factory.getBean("user");
		
		System.out.println(user.getId());
		
	}
	
	//2. （方便）直接得到IOC容器对象 
	@Test
	public void testAc() throws Exception {
		// 得到IOC容器对象,<span style="color:#FF0000;">这里可以传入多个配置文件路径，用逗号隔开，也可以用数组</span>
		ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
		// 从容器中获取bean
		User user = (User) ac.getBean("user");
		
		System.out.println(user);
	}
}

4. bean对象创建的细节

/**
	 * 1) 对象创建： 单例/多例
	 * 	scope="singleton", 默认值， 即 默认是单例	【service/dao/工具类】
	 *  scope="prototype", 多例； 				【Action对象】
	 * 
	 * 2) 什么时候创建?
	 * 	  scope="prototype"  在用到对象的时候，才创建对象，懒加载。
	 *    scope="singleton"  在启动(容器初始化之前)， 就已经创建了bean，且整个应用只有一个。
	 * 3)是否延迟创建
	 * 	  lazy-init="false"  默认为false,  不延迟创建，即在启动时候就创建对象
	 * 	  lazy-init="true"   延迟初始化， 在用到对象的时候才创建对象
	 *    （只对单例有效）
	 * 4) 创建对象之后，初始化/销毁
	 * 	  init-method="init_user"       【对应对象的init_user方法，在对象创建爱之后执行 】
	 *    destroy-method="destroy_user"  【在调用容器对象的destriy方法时候执行，(容器用实现类)】
	 */
	@Test
	public void testIOC() throws Exception {
		// 得到IOC容器对象  【用实现类，因为要调用销毁的方法】
		ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
		System.out.println("-----容器创建-----");
		
		// 从容器中获取bean
		User user1 = (User) ac.getBean("user");
		User user2 = (User) ac.getBean("user");
		
		System.out.println(user1);
		System.out.println(user2);
		
		// 销毁容器对象 
		ac.destroy();
	}

5. SpringIOC容器

1）创建对象

SpringIOC容器，是spring核心内容。

作用：创建对象 & 处理对象的依赖关系

IOC容器创建对象：

创建对象, 有几种方式：

1）调用无参数构造器

2）带参数构造器

3）工厂创建对象

工厂类，静态方法创建对象

工厂类，非静态方法创建对象

<?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.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
	
	<!-- ###############对象创建############### -->
	
	<!-- 1. 默认无参数构造器 
	<bean id="user1" class="cn.itcast.b_create_obj.User"></bean>
	-->
	
	<!-- 2. 带参数构造器 -->
	<bean id="user2" class="cn.itcast.b_create_obj.User">
		<constructor-arg index="0" type="int" value="100"></constructor-arg>
		<constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
	</bean>
	
	<!-- 定义一个字符串，值是"Jack" ;  String s = new String("jack")-->
	<bean id="str" class="java.lang.String">
		<constructor-arg value="Jacks"></constructor-arg>
	</bean>
	<bean id="user3" class="cn.itcast.b_create_obj.User">
		<constructor-arg index="0" type="int" value="100"></constructor-arg>
		<constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
	</bean>
	
	
	<!-- 3. 工厂类创建对象 -->
	<!-- # 3.1 工厂类，实例方法 -->
	<!-- 先创建工厂 -->
	<bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>
	<!-- 在创建user对象，用factory方的实例方法 -->
	<bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>
	
	
	<!-- # 3.2 工厂类： 静态方法 -->
	<!-- 
		class 指定的就是工厂类型
		factory-method  一定是工厂里面的“静态方法”
	 -->
	<bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>
	
</beans>

2）对象依赖关系

Spring中，如何给对象的属性赋值? 【DI, 依赖注入】

1) 通过构造函数

2) 通过set方法给属性注入值

3)p名称空间

4)自动装配(了解)

5)注解

个人觉得还是第五种方式，注解最好用。

#常用的set方法注入值

注意：要先写对象的set方法，再配置才有效。比如在UserService类中创建方法setUserDao();

<!-- dao instance -->
	<bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>

	<!-- service instance -->
	<bean id="userService" class="cn.itcast.c_property.UserService">
		<property name="userDao" ref="userDao"></property>
	</bean>
	
	<!-- action instance -->
	<bean id="userAction" class="cn.itcast.c_property.UserAction">
		<property name="userService" ref="userService"></property>
	</bean>

#内部bean

!-- ##############内部bean############## -->
	<bean id="userAction" class="cn.itcast.c_property.UserAction">
		<property name="userService">
			<bean class="cn.itcast.c_property.UserService">
				<property name="userDao">
					<bean class="cn.itcast.c_property.UserDao"></bean>
				</property>
			</bean>
		</property>
	</bean>

#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"
    <span style="color:#FF0000;">xmlns:p="http://www.springframework.org/schema/p"</span>
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
	
	<!-- ###############对象属性赋值############### -->
	
	<!-- 
		给对象属性注入值：
			# p 名称空间给对象的属性注入值
			 (spring3.0以上版本才支持)
	 -->
	 <bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>
	 
	 <bean id="userService" class="cn.itcast.c_property.UserService" <span style="color:#FF0000;">p:userDao-ref="userDao"</span>></bean>
	 
	 <bean id="userAction" class="cn.itcast.c_property.UserAction" <span style="color:#FF0000;">p:userService-ref="userService"</span>></bean>
	
	
	<!-- 传统的注入： 
	 <bean id="user" class="cn.itcast.c_property.User" >
	 	<property name="name" value="xxx"></property>
	 </bean>
	-->
	<!-- p名称空间优化后 -->
	<bean id="user" class="cn.itcast.c_property.User" p:name="Jack0001"></bean>
	 
</beans>

#自动装配

<!-- ###############自动装配############### -->  
	<bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>	
	<bean id="userService" class="cn.itcast.d_auto.UserService" autowire="byName"></bean>
	<!-- 根据“名称”自动装配： userAction注入的属性，会去ioc容器中自动查找与属性同名的对象 -->
	<bean id="userAction" 
class="cn.itcast.d_auto.UserAction" autowire="byName"></bean>

Spring提供的自动装配主要是为了简化配置；但是不利于后期的维护。 就是基本没什么用。

#注解

注解方式可以简化spring的IOC容器的配置!

使用注解步骤：

1）先引入context名称空间

xmlns:context="http://www.springframework.org/schema/context"

2）开启注解扫描

<context:component-scanbase-package="cn.itcast.e_anno2"></context:component-scan>

3）使用注解

通过注解的方式，把对象加入ioc容器。

创建对象以及处理对象依赖关系，相关的注解：

@Component 指定把一个对象加入IOC容器

@Repository 作用同@Component；在持久层使用

@Service 作用同@Component；在业务逻辑层使用

@Controller 作用同@Component；在控制层使用

@Resource 属性注入

总结：

1）使用注解，可以简化配置，且可以把对象加入IOC容器,及处理依赖关系(DI)
2）注解可以和XML配置一起使用。

2YSP

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
学习笔记之Spring框架

1.Spring框架的作用：简单来说，Spring主要就是用来处理dao层，service层以及action层的对象的创建以及对象的依赖关系。2.专业术语组件/框架设计：侵入式设计引入了框架，对现有的类的结构有影响；即需要实现或继承某些特定类。
复制链接

扫一扫