Spring框架快速上手

最新推荐文章于 2022-03-27 19:58:42 发布
最新推荐文章于 2022-03-27 19:58:42 发布
阅读量589 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Flora_SM/article/details/103798949
版权

Spring是一种轻量级的、开源的JavaEE应用软件框架，框架的主要优势之一就是其分层架构，允许选择使用哪一个组件。

Spring的核心是控制反转(IoC:Inversion of Control)和面向切面(AOP:Aspect Oriented Programming).

Spring的优点：

  • 方便解耦，简化开发（高内聚低耦合）:Spring就是一个大工厂（容器），可以将所有对象创建和依赖关系维护，交给Spring管理；Spring工厂是用于生成bean。
  • AOP编程的支持：可以方便的实现对程序进行权限拦截、运行监控等功能。
  • 声明式事务的支持：只需要通过配置就可以完成对事务的管理，而无需手动编程。
  • 方便程序的测试：Spring对Junit4支持，可以通过注解方便的测试Spring程序。
  • 方便集成各种优秀框架：例如对Struts、Hibernate、MyBatis、Quartz等的直接支持
  • 降低JavaEE API的使用难度

（一）搭建Spring环境

  • 下载Spring
  • 安装Springsource-tool-suite插件

（二）开发过程

  • 根据业务要求创建实体类或给出接口的实现
  •  利用所创建的类，在配置文件中配置Bean信息
  • 创建Spring容器（该容器与配置文件相关联——读取配置信息）
  • 从容器中获取实例对象，由对象调用方法完成所需要的业务处理

（三）案例

eg1:简单案例（利用构造器注入方式——bean)

//1.实体类
package entity;

public class Computer {  //电脑类

	private String cpu;  //大脑
	private String hdd;  //硬盘
	private String mainborder;  //主板
	
	public void setCpu(String cpu) {
		this.cpu = cpu;
	}
	public void setHdd(String hdd) {
		this.hdd = hdd;
	}
	public void setMainborder(String mainborder) {
		this.mainborder = mainborder;
	}
	@Override
	public String toString() {
		return "Computer [cpu=" + cpu + ", hdd=" + hdd + ", mainborder=" + mainborder + "]";
	}
}

//2. applicationContext.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:context="http://www.springframework.org/schema/context" xmlns:util="http://www.springframework.org/schema/util"  
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">
	
	<!-- 构造器注入,创建对象.  类名class=包名.类名-->
	<bean id="cal" class="java.util.GregorianCalendar"></bean>  <!--引用系统类-->
	
	<bean id="com" class="entity.Computer">
	    <!-- 给对象的变量赋值的方式是set注入（用set函数） -->
	    <!-- property的name属性值与set方法有关，即set方法名首字母小写 -->
	    <property name="cpu" value="英特尔" ></property>  <!-- 该name的set函数是setCpu，所以name只用小写的cpu即可。 -->
	    <property name="hdd" value="西数" ></property>
	</bean>
	
</beans>

//3. 测试类（用JUnit4进行测试）
package controller;

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

public class TestSpringIOC {
	
	ApplicationContext ac;
	
	@Before
	public void bf(){
		ac=new ClassPathXmlApplicationContext("applicationContext.xml");
	}
	@Test
	public void test01(){
		Object obj=ac.getBean("cal"); 
		System.out.println(obj);
	}
	
	@Test
	public void test03(){
		Object obj=ac.getBean("com"); 
		System.out.println(obj);
	}

//执行过程：在new applicationContext时创建容器，容器加载xml文件来创建对象，由getBean(id)匹配xml文件中相应的id取对象。
}

运行结果： 

eg2:简单案例（采用注解方式创建Studnet对象和Computer对象，并使用@Resource和@Value注入值显示） 

1. Computer.java
package com.albb.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component   //相当于<bean id="computer"(默认类名小写） class="controller.Computer">
public class Computer {

	@Value("xiaomi")  //配置单个属性的值
	private String cpu;

	public String getCpu() {
		return cpu;
	}

	public void setCpu(String cpu) {
		this.cpu = cpu;
	}

	@Override
	public String toString() {
		return "Computer [cpu=" + cpu + "]";
	}
}

2. Student.java

package com.albb.entity;

import javax.annotation.Resource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import com.albb.controller.Computer;

@Component("stu")  //可修改id值，相当于<bean id="stu" class="entity.Student">
public class Student {

	@Value("flora")
	private String name;
	
	@Resource(name="computer") //相当于为引用对象赋值,name值为Computer对象的id值
	private Computer com;

	public Computer getCom() {
		return com;
	}

	public void setCom(Computer com) {
		this.com = com;
	}

	public String getName() {
		return name;
	}

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

	@Override
	public String toString() {
		return "Student [name=" + name + ", com=" + com + "]";
	}
}

3. applicationContext.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:context="http://www.springframework.org/schema/context" xmlns:util="http://www.springframework.org/schema/util"  
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">
	
	<!-- 告诉框架去扫描包中含注解的类 -->
	<!-- 如果扫描的包太多，可以给所有的包起个公共的包头名，只写公共头部分即可 -->
	<context:component-scan base-package="com.albb"></context:component-scan>
	
</beans>

4. testSpring.java

package test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.albb.controller.Computer;
import com.albb.entity.Student;

public class TestSpring {

	@Test
	public void test01(){
		ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
		Computer com=(Computer)ac.getBean("computer");
		System.out.println(com);	
		
	}
	
	@Test
	public void test02(){
		ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
		Student stu=(Student)ac.getBean("stu");
		System.out.println(stu);	
		
	}
}

运行结果：

eg3:利用Spring框架的IoC思想，设计Java程序实现控制台的学生信息显示

（1）创建Java工程，导入必需的jar包
（2）创建实体类：HelloBean.java,该类用于描述学生信息
package com.edu;

public class HelloBean {
	private String studentName;// 学生姓名
	private String course;// 选课课程名
	private Double score;// 课程成绩

	public HelloBean() {
	}

	public HelloBean(String studentName, String course, Double score) {
		this.studentName = studentName;
		this.course = course;
		this.score = score;
	}

	public String getStudentName() {
		return studentName;
	}

	public void setStudentName(String studentName) {
		this.studentName = studentName;
	}

	public String getCourse() {
		return course;
	}

	public void setCourse(String course) {
		this.course = course;
	}

	public Double getScore() {
		return score;
	}

	public void setScore(Double score) {
		this.score = score;
	}

}

（3）创建配置文件hellobean.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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean name="stu1" class="com.edu.HelloBean">
		<property name="studentName" value="张三"></property>
		<property name="course" value="数学"></property>
		<property name="score" value="95"></property>
	</bean>
	<bean name="stu2" class="com.edu.HelloBean">
		<property name="studentName" value="李四"></property>
		<property name="course" value="物理"></property>
		<property name="score" value="88"></property>
	</bean>
	<bean name="stu3" class="com.edu.HelloBean">
		<property name="studentName" value="王五"></property>
		<property name="course" value="计算机"></property>
		<property name="score" value="90"></property>
	</bean>

</beans>

（4）设计主方法，完成Spring容器的实例化及业务处理——显示3名学生的信息

package com.edu;

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

public class Main {

	public static void main(String[] args) {
		// (1)创建一个容器实例（与配置文件关联）
		ApplicationContext act = new ClassPathXmlApplicationContext(
				"hellobean.xml");
		// (2)只声明一个对象
		HelloBean student;
		// (3)从实例容器act中，分别获取3个学生对象，并显示信息
		student = (HelloBean) act.getBean("stu1");
		System.out.println("姓名：" + student.getStudentName() + "  课程名："
				+ student.getCourse() + "   成绩：" + student.getScore());
		student = (HelloBean) act.getBean("stu2");
		System.out.println("姓名：" + student.getStudentName() + "  课程名："
				+ student.getCourse() + "   成绩：" + student.getScore());
		student = (HelloBean) act.getBean("stu3");
		System.out.println("姓名：" + student.getStudentName() + "  课程名："
				+ student.getCourse() + "   成绩：" + student.getScore());

	}

}

（2）设计web工程，利用网页显示学生信息

（1）创建web工程，导jar包
（2）创建实体类HelloBean.java，与上面代码相同
（3）创建配置文件hellobean.xml，与上面代码相同
（4）实例化Spring容器：在web.xml中配置Spring容器
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  <display-name>spring_2_web_helloword</display-name>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:hellobean.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>
（5）设计网页：采用脚本代码，获取Spring容器，从容器内获取对象并显示
<%@page import="com.edu.HelloBean"%>
<%@page import="org.springframework.web.context.WebApplicationContext"%>
<%@page import="org.springframework.web.context.support.WebApplicationContextUtils"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
      <%
        // (1)首先通过request对象，获取web服务器容器
        ServletContext sc=request.getServletContext();              
        //(2)利用Spring框架提供ServletContext的静态方法，从Web服务器中获取 Spring容器 
		WebApplicationContext wact =WebApplicationContextUtils.getRequiredWebApplicationContext(sc);
		// (3)只声明一个对象
		HelloBean student;
		// (4)从实例容器act中，分别获取3个学生对象，并显示信息
		student = (HelloBean) wact.getBean("stu1");
		//(5)利用Jsp脚本获取数据并显示 
		%>		
		 姓名：<%=student.getStudentName()%><br>
		 课程名：<%=student.getCourse()%><br>		 
		 成绩：<%=student.getScore()%><br>
		--------------------------------------<br>
		<%student = (HelloBean) wact.getBean("stu2"); %>
		 姓名：<%=student.getStudentName()%><br>
		 课程名：<%=student.getCourse()%><br>		 
		 成绩：<%=student.getScore()%><br>
		--------------------------------------<br>
		<%student = (HelloBean) wact.getBean("stu3"); %>
		 姓名：<%=student.getStudentName()%><br>
		 课程名：<%=student.getCourse()%><br>		 
		 成绩：<%=student.getScore()%><br>
		--------------------------------------
</body>
</html>

 

Flora_M
关注
专栏目录
快速上手Spring Security
m0_69661182的博客
09-04 291
快速上手，授之以鱼
Spring MVC快速上手教程
热门推荐
DigitalSonic的自留地
04-01 4万+
Spring Framework可以被使用在很多场合之中，考虑到目前大多数Java EE的项目是B/S结构的，所以这里的快速上手教程会以Spring MVC为切入点，用最简单的代码一步一步来实现一个图书列表的页面。在正式动手之前需要做一些准备工作，先安装并设置好JDK 1.5和Tomcat 5，关于数据库及其访问方式可以根据个人习惯进行选择，教程中使用MySQL数据库和Hibernate（映射
快速上手Spring－－1.收集的一些资料
分享Java快乐
06-23 1万+
      “好的开始是成功的一半”，但凡一种新的技术，开始阶段一般是很苦恼的。为了不让更多的人走同样的弯路，我这里就把学习Spring的经验与大家分享， 一起快乐一下。    Spring是什么？反正这里我不会谈论春天的。我要说的是Spring Framework ,它又是用来做什么的呢？一会半会我也说不清楚。还好现在是互联网的时代，google一下，会发现不少有用的东西。       先来到S
Spring从入门到入土——快速上手Spring
冢狐的私人空间
05-03 1155
HelloSpring 导入依赖 ​ 我们要想使用Spring，首先肯定要先导入其jar包，我们只需要在maven配置文件中加入响应的依赖，就会自动下载相应的依赖项， <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> <dependency> <group...
Spring学习（3）——IOC创建对象的方式及Spring配置
08-09 246
通过无参构造方法来创建（默认） User.java public class User { private String name; public User(){ System.out.println("User无参构造方法"); } public String getName() { return name; } public void setName(String name) { this.name
Spring——第一个Spring程序
Galip的博客
12-27 189
第一个程序、对象创建方式、配置说明 导入Jar包 注 : spring 需要导入commons-logging进行日志记录 . 我们利用maven , 他会自动下载对应的依赖项 . <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc...
5分钟快速上手Spring Boot
08-26
它的核心目标是让开发者能更快地构建出基于Spring框架的应用，而无需过多的配置。Spring Boot遵循“约定优于配置”的原则，极大地减少了初始化和配置的工作量。 在开始上手Spring Boot前，确保你的开发环境准备就绪...
SSM框架整合快速上手
05-26
Spring框架是SSM中的基础，它是一个全面的后端应用程序管理框架，提供了一系列丰富的功能，如依赖注入（DI）、面向切面编程（AOP）、事务管理、数据访问/集成、远程服务、Web服务等。在SSM整合中，Spring主要负责...
若依框架前后端分离版 快速上手 前端（vue）版
10-05
【标题】：“若依框架前后端分离版 快速上手 前端（vue）版” 【描述】：这个教程主要关注的是若依框架在前后端分离模式下的前端实现，采用Vue.js作为主要开发工具。它旨在帮助开发者快速理解和应用若依框架，通过...
狂神说Spring02：快速上手Spring
狂神说
04-16 1万+
狂神说Spring系列连载课程，通俗易懂，基于Spring最新版本，欢迎各位狂粉转发关注学习。禁止随意转载，转载记住贴出B站视频链接及公众号链接！Hello，Spring狂神说Sprin...
Spring入门（二）——快速上手Spring
m0_53417604的博客
03-27 634
3、HelloSpring 新建一个maven项目，编写实体类 package com.ysl.pojo; public class Hello { private String str; public String getStr() { return str; } public void setStr(String str) { this.str = str; } @Override public Str
快速上手Spring－－2.HelloWorld(2)
分享Java快乐
06-27 9883
这是第二部分。3. 采用“工厂模式” · 新建一个包，包名：javamxj.spring.beginning2,在这个包下，新建一个“Hello”接口，这个接口含有一个方法。  Hello.javapackage javamxj.spring.beginning2;public interface Hello {    void sayHello();} · 分别新建两个类，实现这个接口。 Hel
Spring4.3入门 快速上手Spring
Fly to sky
11-25 515
Spring Spring 框架是一个集合了很多东西的框架, 最核心最底层的就是IoC/DI. 在这个基础之上, 有很多诸如 AOC, ORM, WebMVC, DAO, Context 之类的功能(容器). IoC/DI 控制反转, 依赖注入. 就是你的类对应的对象不用你来 new, 框架帮你 new, 帮你 new 完了再放到你指定的变量里面, 你直接用就行. 他还帮你管理他什么时
Spring入门一键快速上手
qq_1243443888的博客
06-28 155
Spring入门 Spring概述 ​ Spring 框架为任何类型的部署平台上的基于 Java 的现代企业应用程序提供了全面的编程和配置模型。 ​ 简单来说，Spring 是一个免费开源框架，为了简化企业级项目开发，提供全面的开发部署解决方案。 Spring体系结构介绍 ​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3p81d9Gt-1593331120460)(assets/1593326631168.png)] ​ 结构图解释 持久层的部分，是 Spring 对数
Spring Boot 快速上手（一）快速搭建
xxpsw的博客
10-01 1551
Spring Boot官网提供了快速搭建Spring Boot项目的方法，通过官网，可快速构建基于maven的Spring Boot项目。
3、Spring：快速上手Spring
Surplus.的博客
09-03 110
HelloSpring 导入Jar包 注 : spring 需要导入commons-logging进行日志记录 . 我们利用maven , 他会自动下载对应的依赖项 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.1.10.RELEASE</version&g
Spring框架快速入门
weixin_40052304的博客
06-22 173
目录 什么是Spring？ 为什么学习Spring？ Spring的快速入门 Spring的版本 IOC概述 什么是IOC？ Spring的IoC入门 下载Spring的开发包 创建web项目，引入Spring的开发包 创建接口和实现类 编写测试类 Spring IoC和DI的区别 什么是Spring？ Spring是一个轻量级的Java开发框架。Spring的核心是控制反转（IoC）和面向切面（AOP），简单来说，Spring是一个分层的JavaSE/EEfull-stack（
Spring框架入门教程：快速上手指南
"Spring入门教程，适合初学者，由作者夏昕编写的Spring Framework Developer’s Guide V0.6预览版，包含Spring框架的基础知识和持久层内容。" Spring框架是一个广泛使用的Java企业级应用程序开发框架，它为开发者...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值