MasterYangBlog
首页
时间轴
标签
分类
友链
留言板
关于
avatar
文章
72
标签
51
分类
27
首页
时间轴
标签
分类
友链
留言板
关于
目录
  1. 1. 简单了解框架
  2. 2. 第1章 Spring
    1. 2.1. 1.1 Spring 概述
    2. 2.2. 1.2 Spring HelloWorld
    3. 2.3. 1.3 基于注解开发Spring应用
      1. 2.3.1. 1.3.1 常用注解标识组件
      2. 2.3.2. 1.3.2 组件命名规则
      3. 2.3.3. 1.3.3 Spring HelloWorld 注解版
      4. 2.3.4. 1.3.4 @Autowired注解
      5. 2.3.5. 1.3.5 基于注解装配
spring精简教程
|JavaWebspring
阅读量:

简单了解框架

框架，即framework。其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。简单说就是使用别人搭好的舞台，你来做表演。而且，框架一般是成熟的，不断升级的软件。

框架是对特定应用领域中的应用系统的部分设计和实现的整体结构。

因为软件系统发展到今天已经很复杂了，特别是服务器端软件，涉及到的知识，内容，问题太多。在某些方面使用别人成熟的框架，就相当于让别人帮你完成一些基础工作，你只需要集中精力完成系统的业务逻辑设计。而且框架一般是成熟，稳健的，他可以处理系统很多细节问题，比如，事务处理，安全性，数据流控制等问题。还有框架一般都经过很多人使用，所以结构很好，所以扩展性也很好，而且它是不断升级的，你可以直接享受别人升级代码带来的好处。

第1章 Spring

1.1 Spring 概述

1) Spring是一个开源框架

2) Spring为简化企业级开发而生，使用Spring，JavaBean就可以实现很多以前要靠EJB才能实现的功能。同样的功能，在EJB中要通过繁琐的配置和复杂的代码才能够实现，而在Spring中却非常的优雅和简洁。

3) Spring是一个IOC(DI)和AOP容器框架。

4) Spring的优良特性

① 非侵入式：基于Spring开发的应用中的对象可以不依赖于Spring的API

② 依赖注入：DI——Dependency Injection，反转控制(IOC)最经典的实现。

③ 面向切面编程：Aspect Oriented Programming——AOP

④ 容器：Spring是一个容器，因为它包含并且管理应用对象的生命周期

⑤ 组件化：Spring实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用XML和Java注解组合这些对象。

⑥ 一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库（实际上Spring
自身也提供了表述层的SpringMVC和持久层的Spring JDBC）。

5) Spring模块

Image

1.2 Spring HelloWorld

1) 创建一个Maven版的Java工程

2) 在pom.xml中加入对Spring的依赖

xml
1
2
3
4
5
<dependency>
  	  <groupId>org.springframework</groupId>
	  <artifactId>spring-context</artifactId>
	  <version>4.0.0.RELEASE</version>
</dependency>

3) 创建Spring的核心配置文件

  • File->New->Spring Bean Configuration File
  • 为文件取名字 例如：applicationContext.xml
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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


</beans>

4) 编写组件

  • 创建控制层组件
java
1
2
3
4
5
6
7
8
9
10
package com.ys.spring.controller;
/**
 * 控制层组件  处理客户端的请求，给客户端响应
 */
import com.ys.spring.service.UserService;

public class UserController {
    public void  listAllUsers() {
	}
}
  • 创建业务层组件接口
java
1
2
3
4
5
6
7
package com.ys.spring.service;
/**
 * 业务层组件   处理业务逻辑
 */
public interface UserService {
	public void  doGetAllUser();
}
  • 创建业务层组件实现类
java
1
2
3
4
5
6
7
8
9
10
package com.ys.spring.service;

import com.ys.spring.dao.UserDao;

public class UserServiceImpl  implements UserService{
	
	@Override
	public void doGetAllUser() {
	}
}
  • 创建持久层组件接口
java
1
2
3
4
5
6
7
8
9
package com.ys.spring.dao;
/**
 * 持久层组件  负责数据库的CRUD操作
 *
 */
public interface UserDao {
	
	public void selectAllUsers();
}
  • 创建持久层组件实现类
java
1
2
3
4
5
6
7
8
9
package com.ys.spring.dao;

public class UserDaoJdbcImpl implements UserDao  {
	
	@Override
	public void selectAllUsers() {
		System.out.println("UserDaoJdbcImpl  selectAllUsers  Success .....");
	}
}
  • 在spring的核心配置文件中管理Bean
xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?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">
	
	<!-- 管理组件 -->
	<!-- 
		bean: 对应一个被Spring管理的组件对象
		 	id: bean的唯一标识
		 	class: 组件对象对应的类的全类名
	 -->	
	<bean id="userController" class="com.ys.spring.controller.UserController">
	</bean>
	<bean id="userServiceImpl" class="com.ys.spring.service.UserServiceImpl">
	</bean>
	<bean id="userDaoJdbcImpl" class="com.ys.spring.dao.UserDaoJdbcImpl"></bean>

</beans>
  • 编写测试类
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.ys.spring.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ys.spring.controller.UserController;
import com.ys.spring.dao.UserDao;
import com.ys.spring.service.UserService;

public class TestSpring {
	
	@Test
	public void testSpringXML() {
		//1. 先创建Spring的容器对象
		ApplicationContext ctx = 
				new ClassPathXmlApplicationContext("applicationContext.xml");
		
		//2. 从Spring的容器中获取Bean对象
		UserController uc = ctx.getBean("userController", UserController.class);
		System.out.println("uc:" + uc);
		UserService us = ctx.getBean("userServiceImpl",UserService.class);
		System.out.println("us:" + us );
		UserDao ud = ctx.getBean("userDaoJdbcImpl",UserDao.class);
		System.out.println("ud:" + ud );		
	}
}

5) 组件装配

  • 在控制层组件中定义业务层组件类型的属性
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.ys.spring.controller;
/**
 * 控制层组件  处理客户端的请求，给客户端响应
 */

import com.ys.spring.service.UserService;

public class UserController {

	private UserService userService ;
	public void setUserService(UserService userService) {
		this.userService = userService;
	}
	
	public void  listAllUsers() {
		userService.doGetAllUser();
	}
}
  • 在业务层组件中定义持久层组件类型的属性
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.ys.spring.service;

import com.ys.spring.dao.UserDao;

public class UserServiceImpl  implements UserService{
	
	private UserDao userDao ;
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}
	
	@Override
	public void doGetAllUser() {
		userDao.selectAllUsers();
	}
}
  • 在Spring的核心配置文件中完成组件装配
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?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">
	
	<!-- 管理组件 -->
	<!-- 
		bean: 对应一个被Spring管理的组件对象
		 	id: bean的唯一标识
		 	class: 组件对象对应的类的全类名
	 -->	
	<bean id="userController" class="com.ys.spring.controller.UserController">
		<!-- 给属性注入值 -->
		<property name="userService" ref="userServiceImpl"></property>
	</bean>
	
	<bean id="userServiceImpl" class="com.ys.spring.service.UserServiceImpl">
		<property name="userDao" ref="userDaoJdbcImpl"></property>
	</bean>
	<bean id="userDaoJdbcImpl" class="com.ys.spring.dao.UserDaoJdbcImpl"></bean>

</beans>
  • 测试控制层 业务层 持久层的调用
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
package com.ys.spring.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ys.spring.controller.UserController;
import com.ys.spring.dao.UserDao;
import com.ys.spring.service.UserService;

public class TestSpring {
	
	@Test
	public void testSpringXML() {
		//1. 先创建Spring的容器对象
		ApplicationContext ctx = 
				new ClassPathXmlApplicationContext("applicationContext.xml");
		
		//2. 从Spring的容器中获取Bean对象
		UserController uc = ctx.getBean("userController", UserController.class);
		System.out.println("uc:" + uc);
		UserService us = ctx.getBean("userServiceImpl",UserService.class);
		System.out.println("us:" + us );
		UserDao ud = ctx.getBean("userDaoJdbcImpl",UserDao.class);
		System.out.println("ud:" + ud );
		
		uc.listAllUsers();
	}
}

1.3 基于注解开发Spring应用

1.3.1 常用注解标识组件

1) 普通组件：

@Component 标识一个受Spring IOC容器管理的组件

2) 持久化层组件：

@Repository 标识一个受Spring IOC容器管理的持久化层组件

3) 业务逻辑层组件：

@Service 标识一个受Spring IOC容器管理的业务逻辑层组件

4) 表述层控制器组件：

@Controller 标识一个受Spring IOC容器管理的表述层控制器组件

1.3.2 组件命名规则

1) 默认情况：使用组件的简单类名首字母小写后得到的字符串作为bean的id

2) 使用组件注解的value属性指定bean的id

3) 注意：事实上Spring并没有能力识别一个组件到底是不是它所标记的类型，即使将
@Respository注解用在一个表述层控制器组件上面也不会产生任何错误，所以
@Respository、@Service、@Controller这几个注解仅仅是为了让开发人员自己 明确当前的组件扮演的角色。

1.3.3 Spring HelloWorld 注解版

1) 在控制层 业务层 持久层组件标注对应的注解

  • 在控制层组件标注注解
java
1
2
3
@Controller
public class UserController {
}
  • 在业务层组件标注注解
java
1
2
3
@Service
public class UserServiceImpl  implements UserService{
}
  • 在持久层组件标注注解
java
1
2
3
@Repository
public class UserDaoJdbcImpl implements UserDao  {
}

2) 在Spring的核心配置文件中开启组件扫描

  • 首先在xml文件中的namespace视图下勾选context名称空间

img

  • 在Spring的核心配置文件中开启组件扫描
xml
1
2
3
4
5
6
7
8
9
10
11
12
13
<?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: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-4.0.xsd">
	<!-- 组件扫描 
		 base-package: 基本包
		 Spring会扫描通过base-package指定的包下以及子包下的组件，将带有Spring相关
         注解的类管理到IOC容器中。
	 -->
	<context:component-scan base-package="com.ys.spring"></context:component-scan>	
</beans>

3) 编写测试类

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
package com.ys.spring.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ys.spring.controller.UserController;
import com.ys.spring.dao.UserDao;
import com.ys.spring.service.UserService;

public class TestSpring {
	
	@Test
	public void testSpringXML() {
		//1. 先创建Spring的容器对象
		ApplicationContext ctx = 
				new ClassPathXmlApplicationContext("applicationContext.xml");	
		//2. 从Spring的容器中获取Bean对象
		UserController uc = ctx.getBean("userController", UserController.class);
		System.out.println("uc:" + uc);
		UserService us = ctx.getBean("userServiceImpl",UserService.class);
		System.out.println("us:" + us );
		UserDao ud = ctx.getBean("userDaoJdbcImpl",UserDao.class);
		System.out.println("ud:" + ud );			
	}
}

1.3.4 @Autowired注解

1) @Autowired的工作机制

  • 首先会通过当前被装配的属性的类型到IOC容器中去匹配对应的Bean对象,如果能唯一确定一个bean对象，则装配成功
  • 当通过当前被装配的属性的类型匹配在IOC容器中匹配到多个对应的Bean对象时，
    会再使用当前被装配的属性的名字与匹配到的Bean对象的id值再进行唯一确定，如果能确定唯一一个，则装配
    成功，否则，抛出异常

expected single matching bean but found 2:
userDaoJdbcImpl,userDaoMyBatisImpl

  • 如果被装配的属性在IOC容器中匹配不到任何一个Bean对象，也会抛出异常

expected at least 1 bean which qualifies as autowire candidate for
this dependency.

Dependency annotations:

@org.springframework.beans.factory.annotation.Autowired(required=true)}

  • 如果匹配到多个Bean的情况，并且通过属性名也无法唯一确定一个Bean的时候，可以手动通过@Qualifier注解来具体指定装配哪个Bean对象.
  • @Autowired 注解中required的属性默认是true，表示属性必须被装配，可以改为false，表示可选.也就是
    有就装配，没有就不装配.
  • @Autowired 和 @Qualifier 注解可以加在属性上，也可以加在方法上。

1.3.5 基于注解装配

1) 在 控制层 和 业务层分别定义需要被装配的组件类型的属性,并在属性上标注注解

  • 在控制层中定义业务层类型的属性 和 相关方法
java
1
2
3
4
5
6
7
8
9
@Controller
public class UserController {
	@Autowired
	private UserService userService ;
	
	public void  listAllUsers() {
		userService.doGetAllUser();
	}
}
  • 在业务层中定义持久层类型的属性 和相关方法
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.ys.spring.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import com.ys.spring.dao.UserDao;

@Service
public class UserServiceImpl  implements UserService{
	@Autowired
	private UserDao userDao ;

	@Override
	public void doGetAllUser() {
		userDao.selectAllUsers();
	}
}
  • 在持久层中定义相关方法
java
1
2
3
4
5
6
7
8
@Repository
public class UserDaoJdbcImpl implements UserDao  {
	
	@Override
	public void selectAllUsers() {
		System.out.println("UserDaoJdbcImpl  selectAllUsers  Success .....");
	}
}

2) 在测试方法中测试 控制层 业务层 持久层的调用

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
package com.ys.spring.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ys.spring.controller.UserController;
import com.ys.spring.dao.UserDao;
import com.ys.spring.service.UserService;

public class TestSpring {	
	@Test
	public void testSpringXML() {
		//1. 先创建Spring的容器对象
		ApplicationContext ctx = 
				new ClassPathXmlApplicationContext("applicationContext.xml");
		
		//2. 从Spring的容器中获取Bean对象
		UserController uc = ctx.getBean("userController", UserController.class);
		System.out.println("uc:" + uc);
		UserService us = ctx.getBean("userServiceImpl",UserService.class);
		System.out.println("us:" + us );
		UserDao ud = ctx.getBean("userDaoJdbcImpl",UserDao.class);
		System.out.println("ud:" + ud );
		uc.listAllUsers();
		//【注意】id首字母要小写
	}
}
文章作者: Yang4
文章链接: https://masteryang4.github.io/2020/06/14/spring%E7%B2%BE%E7%AE%80%E6%95%99%E7%A8%8B/
版权声明: 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 MasterYangBlog！
教程 JavaWeb spring
打赏
  • 微信
    微信
  • 支付宝
    支付宝
相关推荐
2020-05-12
[精]Redis总结与思考
2020-06-14
springboot精简教程
2020-06-19
spark系列之spark-core
2020-06-17
spark系列之spark-streaming
2020-08-09
flink系列12电商用户行为分析
2020-07-02
flink系列11Table API 和 Flink SQL
评论
简