`
taody
  • 浏览: 100174 次
  • 性别: Icon_minigender_2
  • 来自: 北京
社区版块
存档分类
最新评论

Spring框架学习笔记1：Spring简介，入门示例和Spring基础

springaopiocjavaspring入门示例学习 
阅读更多

 

 

1.Spring简介,有什么作用及其好处

Spring主要的作用是解耦,用于降低组件与组件关系,提高了程序结构的灵活性.在项目中主要使用该框架的IOC和AOP两个特性.

2.IOC概念

Inverse of Contorl 反向控制,控制反转

控制权是指对象的创建和调用的关系指定.

3.Spring入门示例 HelloWorld!

1)引入spring开发包

spring.jar,commons-logging.jar

 

2)在src下添加spring配置文件

applicationContext.xml

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:tx="http://www.springframework.org/schema/tx" 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd" default-lazy-init="true">
</beans>

3)将程序的Bean组件在spring配置中定义,交给spring框架管理

Bean组件由spring框架负责创建和调用关系指定.

—->HelloBeanZh

MessageBean—>HelloBean—|

—->HelloBeanEn

HelloBean组件：

1
2
3
4
5

package com.weishuzhai.bean;
 
public interface HelloBean {
	public void say();
}

HelloBeanZh组件：

1
2
3
4
5
6
7
8
9

package com.weishuzhai.bean;
 
public class HelloBeanZh implements HelloBean {
 
	public void say() {
		System.out.println("---- 你好，欢迎学习spring! ----");
	}
 
}

MessageBean组件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package com.weishuzhai.bean;
 
public class MessageBean {
	private HelloBean hello;
 
	public void show() {
		System.out.println("---- 消息如下: ----");
		hello.say();
	}
 
	public HelloBean getHello() {
		return hello;
	}
 
	public void setHello(HelloBean hello) {
		this.hello = hello;
	}
 
}

各组件在spring配置文件 applicationContext.xml中的配置：

1
2
3
4
5
6
7

< ?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:tx="http://www.springframework.org/schema/tx" 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd" default-lazy-init="true">
	<bean id="helloBean" class="com.weishuzhai.bean.HelloBeanZh"/>
	<bean id="messageBean" class="com.weishuzhai.bean.MessageBean">
		<property name="hello" ref="helloBean"></property>
	</bean>
</beans>

进行测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package com.weishuzhai.bean.test;
 
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.weishuzhai.bean.MessageBean;
 
public class TestMessageBean {
	// test1写法出现空指针异常，应该如test2方法。
	// @Test
	public void test1() {
		MessageBean bean = new MessageBean();
		bean.show();
	}
 
	@Test
	public void test2() {
		String[] configs = { "applicationContext.xml" };
		ApplicationContext ac = new ClassPathXmlApplicationContext(configs);
		MessageBean message = (MessageBean) ac.getBean("messageBean");
		message.show();
	}
}

运行结果：

4. Spring基础

1)Spring容器实例化

a. ApplicationContext (容器对象,可使用getBean()方法)

优先于BeanFactory,功能比BeanFactory强大.

ClassPathXmlApplicationContext

FileSystemXmlApplicationContext

b.BeanFactory(提供了对象创建\关系\定位等功能)

XMLBeanFactory

2)Spring容器对对象的管理

a.如何使容器管理某个组件

1

<bean id="标识符" class="包名.类型"/>

b.对象创建时机

默认情况下,bean对象是在容器创建时也一起创建出来.

可以在xml配置中使用配置,指定延迟创建Bean对象.

1

<beans default-lazy-init="true"></beans>

控制所有Bean组件。

1

<bean lazy-init="true"></bean>

控制某一个Bean组件。

c.容器创建Bean对象的模式

默认采用singleton(单例)模式.可以使用下面方法改变:

1

<bean scope="prototype"/>

每次调用getBean()将返回一个新实例.

如果应用在Web环境中,还可以指定request,session等

d.指定初始化方法和销毁方法

1

<bean init-method="" destroy-method=""/>

注意:destroy-method对scope=”singleton”才有使用意义

UserBean.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package com.weishuzhai.bean;
 
public class UserBean {
	public UserBean() {
		System.out.println("-----构造方法,创建UserBean对象------");
	}
 
	public void myInit() {
		System.out.println("------初始化方法myInit------");
	}
 
	public void myDestroy() {
		System.out.println("------销毁方法myDestroy------");
	}
}

配置文件applicationContext.xml:

1
2
3
4
5

< ?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:tx="http://www.springframework.org/schema/tx" 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd 				http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd" 	default-lazy-init="true">
 
	<bean id="userBean" class="com.weishuzhai.bean.UserBean"  		scope="singleton" init-method="myInit" destroy-method="myDestroy"></bean>
</beans>

测试执行TestApplicationContext.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package com.weishuzhai.bean.test;
 
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.weishuzhai.bean.UserBean;
 
public class TestApplicationContext {
	// @Test
	public void test1() {
		ApplicationContext ac = new ClassPathXmlApplicationContext(
				"applicationContext.xml");
		UserBean user = (UserBean) ac.getBean("userBean");
	}
 
	@Test
	public void test2() {
		AbstractApplicationContext ac = new ClassPathXmlApplicationContext(
				"applicationContext.xml");
		UserBean user = (UserBean) ac.getBean("userBean");
		UserBean user1 = (UserBean) ac.getBean("userBean");
		System.out.println(user == user1);
		ac.close();
	}
}

运行结果：test1和test2同时执行

3)DI依赖注入(是实现IOC的重要技术)

a.setter方式注入

(1)在对象中定义一个属性及setter方法,属性推荐使用接口

PersonBean.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

package com.weishuzhai.bean;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
 
public class PersonBean {
	private int id;
 
	private String name;
 
	private int age;
 
	private List<string> loves = new ArrayList</string><string>();
 
	private Set</string><string> cities = new HashSet</string><string>();
 
	private Map</string><string , String> books = new HashMap</string><string , String>();
 
	private Properties pros = new Properties();
 
	private HelloBean hello;
 
	public void show() {
		System.out.println("----通过Setter注入了以下信息-----");
		System.out.println("编号" + id);
		System.out.println("姓名" + name);
		System.out.println("年龄" + age);
		System.out.println("----爱好---");
		for (String love : loves) {
			System.out.println(love);
		}
		System.out.println("----城市----");
		for (String city : cities) {
			System.out.println(city);
		}
		System.out.println("----图书信息----");
		Set</string><string> keys = books.keySet();
		for (String key : keys) {
			System.out.println(key + " " + books.get(key));
		}
		System.out.println("-----网址--------");
		Set<object> ids = pros.keySet();
		for (Object id : ids) {
			System.out.println(id + " " + pros.get(id));
		}
		System.out.println("------HelloBean-----");
		hello.say();
	}
 
	public int getAge() {
		return age;
	}
 
	public void setAge(int age) {
		this.age = age;
	}
 
	public Map<string , String> getBooks() {
		return books;
	}
 
	public void setBooks(Map</string><string , String> books) {
		this.books = books;
	}
 
	public Set</string><string> getCities() {
		return cities;
	}
 
	public void setCities(Set</string><string> cities) {
		this.cities = cities;
	}
 
	public HelloBean getHello() {
		return hello;
	}
 
	public void setHello(HelloBean hello) {
		this.hello = hello;
	}
 
	public int getId() {
		return id;
	}
 
	public void setId(int id) {
		this.id = id;
	}
 
	public List</string><string> getLoves() {
		return loves;
	}
 
	public void setLoves(List</string><string> loves) {
		this.loves = loves;
	}
 
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.name = name;
	}
 
	public Properties getPros() {
		return pros;
	}
 
	public void setPros(Properties pros) {
		this.pros = pros;
	}
}

(2)在spring配置中,利用

1

<property name="属性名"></property>

指定参数值

applicationContext.xml配置文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

< ?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:tx="http://www.springframework.org/schema/tx" 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd 				http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd" 	default-lazy-init="true">
 
		<!-- setter方式注入各种类型的信息 -->
		<bean id="personBean" class="com.weishuzhai.bean.PersonBean">
			<property name="id">
			<value>1001</value>
			</property>
			<property name="name">
				<value>Sealter</value>
			</property>
			<property name="age">
				<value>23</value>
			</property>
			<property name="loves">
				<list>
					<value>旅游</value>
					<value>游泳</value>
					<value>编程</value>
				</list>
			</property>
			<property name="cities">
				<set>
					<value>北京</value>
					<value>上海</value>
					<value>青岛</value>
				</set>
			</property>
			<property name="books">
				<map>
					<entry key="1001" value="Java编程基础"></entry>
					<entry key="1002" value="Java高级编程"></entry>
					<entry key="1003" value="Java框架方案"></entry>
					<entry key="1004" value="Java设计模式"></entry>
					<entry key="1005" value="编程之美"></entry>
				</map>
			</property>
			<property name="pros">
				<props>
					<prop key="1">www.weishuzhai.com</prop>
					<prop key="2">www.taoxiaotan.com</prop>
					<prop key="3">www.sina.com</prop>
				</props>
			</property>
			<property name="hello" ref="helloBean"></property>
		</bean>
</beans>

测试执行：

TestPersonBean.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package com.weishuzhai.bean.test;
 
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.weishuzhai.bean.PersonBean;
import com.weishuzhai.bean.UserBean1;
 
public class TestPersonBean {
	@Test
	public void test1() {
		String[] configs = { "applicationContext.xml" };
		ApplicationContext ac = new ClassPathXmlApplicationContext(configs);
		PersonBean person = (PersonBean) ac.getBean("personBean");
		person.show();
	}
 
}

运行结果：

b.构造方法注入

(1)在对象中定义一个带参数的构造方法

UserBean1.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package com.weishuzhai.bean;
 
public class UserBean1 {
	private int id;
 
	private String name;
 
	private int age;
 
	public UserBean1(int id, String name, int age) {
		this.id = id;
		this.name = name;
		this.age = age;
	}
 
	public void show() {
		System.out.println("----通过构造注入了以下信息-----");
		System.out.println("编号" + id);
		System.out.println("姓名" + name);
		System.out.println("年龄" + age);
	}
 
}

(2)在spring配置中,利用

1

<constructor -arg index="0"></constructor>

指定参数值

applicationContext.xml配置文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

< ?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:tx="http://www.springframework.org/schema/tx" 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd 				http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd" 	default-lazy-init="true">
	<!-- 构造方法注入各种类型的信息 -->
	<bean id="userBean1" class="com.weishuzhai.bean.UserBean1">
		<constructor -arg index="0">
			<value>1001</value>
		</constructor>
		<constructor -arg index="1">
			<value>Sealter</value>
		</constructor>
		<constructor -arg index="2">
			<value>23</value>
		</constructor>
	</bean>
</beans>

测试执行 TestPresonBean.java中的test2方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

package com.weishuzhai.bean.test;
 
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.weishuzhai.bean.PersonBean;
import com.weishuzhai.bean.UserBean1;
 
public class TestPersonBean {
	@Test
	public void test2() {
		String[] configs = { "applicationContext.xml" };
		ApplicationContext ac = new ClassPathXmlApplicationContext(configs);
		UserBean1 user = (UserBean1) ac.getBean("userBean1");
		user.show();
	}
}

运行结果：

c.接口注入

附注：name属性和id属性的区别：name可以使用特殊字符，比如”/”。一般使用id属性

分享到：
| Struts2标签详细说明
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java Spring框架学习笔记（内附源码）.pdf

    本学习笔记提供了丰富的源码示例，帮助读者更好地理解和应用Spring框架。 首先，需要明确Spring是一个开源框架，它旨在简化Java EE（现在称为Jakarta EE）的开发。Spring框架的核心是提供了一个轻量级、解耦的容器...

    Spring学习笔记&源码

    本资料“Spring学习笔记&源码”是基于网易云课堂黑马程序员的Spring四天精通课程，旨在帮助学习者深入理解和实践Spring框架。 笔记部分可能会涵盖以下内容： 1. **Spring概述**：介绍Spring框架的历史、特点和主要...

    spring框架学习笔记

    Spring框架是Java应用开发中广泛使用的轻量级框架，它以IoC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）为核心，提供了丰富的功能，包括但不限于组件管理、AOP（Aspect Oriented ...

    动力节点老杜Spring6，配套笔记PDF文件

    动力节点老杜Spring6配套笔记主要讲解了Spring框架的一些核心概念和最佳实践，特别是针对代码设计中的开闭原则（Open-Closed Principle, OCP）进行了深入探讨。在给出的代码示例中，我们可以看到一个简单的用户登录...

    Spring笔记示例源代码

    "Spring笔记示例源代码"这个资源很可能是为了帮助学习者深入理解Spring框架的各种功能和用法而提供的实际代码示例。 1. **Spring IoC**：IoC是Spring的核心特性，它将对象的创建和管理权交给Spring容器，使得开发者...

    Spring5框架课堂笔记.7z

    这份"Spring5框架课堂笔记.pdf"应该详细讲解了以上各知识点，并可能包含示例代码和实践指导，对于学习和进阶Spring框架是非常宝贵的资源。通过深入学习和实践，开发者可以有效地利用Spring5框架构建高效、可维护的...

    读书笔记：springcloud微服务实战示例代码基于最新版本spring cloud.zip

    读书笔记：springcloud微服务实战示例代码基于最新版本spring cloud

    JavaEE精讲之Spring框架实战 ——学习笔记.zip

    在本学习笔记中，我们将深入探讨JavaEE中的Spring框架，这是一个强大的、全面的企业级应用程序开发框架，它简化了Java开发并提供了丰富的功能。Spring的核心特性包括依赖注入（DI）、面向切面编程（AOP）以及对Java ...

    Spring 入门教程资料（源码源代码及课程笔记）

    本入门教程资料是针对初学者和求职者设计的，旨在帮助他们快速掌握 Spring 的基础和关键概念。 在提供的压缩包文件中，我们看到包含了一些以日期或课程编号命名的文件夹，比如 "6-09"、"6-13"、"6-07spring"、"6-08...

    Spring框架笔记

    **步骤1：下载Spring框架** - 访问Spring官方网站 (`http://projects.spring.io/spring-framework/`) 下载最新版本的开发包。 - 通常包括两个压缩包：一个包含了Spring框架的所有jar文件，另一个包含了常见的开源...

    Spring Data JPA 笔记

    至于压缩包中的“helloworld”文件，可能是一个简单的示例项目，通常会包含一个基础的Spring Data JPA配置，一个实体类，以及对应的Repository接口，用于展示Spring Data JPA的基本用法。通过查看这个例子，你可以更...

    Spring Boot 学习笔记完整教程.pdf

    ### Spring Boot 学习笔记知识点 #### 1. Spring Boot 简介 Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。它使用了特定的方式来配置Spring，使得开发者...

    javaSpring学习笔记

    这份学习笔记提供了详细而系统的教程和实践指南，帮助初学者快速入门，并带领已经有一定经验的开发者深入理解和应用Spring框架的各种功能和特性。 在“Java Spring学习笔记”中，你将找到对Spring框架的全面介绍，...

    spring学习笔记0.0.0

    这表明笔记是作者个人的学习和实践心得，可能包含了作者对Spring框架独特的理解和实践经验，可能包括了一些实战案例和解决常见问题的方法。这样的笔记往往具有很高的实用性和个人色彩，可以帮助读者更好地理解和掌握...

    Spring学习总结笔记

    本篇笔记将详细讲解Spring框架的基础知识，包括其模块结构、配置文件的建立、配置文件的加载以及依赖注入的多种方式。 1. **Spring的模块结构** Spring框架由多个模块组成，主要包括： - **Core Container**：...

    spring从入门到精通精简笔记

    ### Spring从入门到精通精简笔记 #### 一、Spring框架概述 Spring 是一个开源的 Java 平台框架，提供了一种全面的方式来管理和控制应用程序的各种组件和服务。它最初由 Rod Johnson 创建，旨在解决企业级应用开发...

    Spring5笔记与代码.zip

    《Spring5笔记与代码》是针对Spring框架第五个主要版本的学习资源，包含了理论知识和实践代码，旨在帮助用户深入理解并掌握Spring5的核心概念和技术。本文将详细解析这些知识点，并结合提供的文件进行深入探讨。 ...

    Spring.NET学习笔记-实现一个简易的IoC框架

    ### Spring.NET学习笔记-实现一个简易的IoC框架 #### 一、背景介绍与理论基础 在.NET领域中，Spring.NET框架是一个非常重要的轻量级框架，它支持依赖注入（Dependency Injection, DI）和面向切面编程（Aspect ...

    spring 入门基础

    - `Spring.txt`：这可能是一个文本文件，里面可能包含了一些关键概念的笔记或者代码示例，可以帮助你理解和实践Spring框架。 在学习Spring的过程中，理解其核心概念并动手实践是至关重要的。通过上述步骤，你可以...

Magicbox
Global site tag (gtag.js) - Google Analytics