java框架技术之spring（一）

最新推荐文章于 2024-02-03 22:09:49 发布

Gailvain

最新推荐文章于 2024-02-03 22:09:49 发布

阅读量772

点赞数 2

分类专栏：框架技术文章标签： spring java

本文链接：https://blog.csdn.net/qq_22905553/article/details/81481773

版权

框架技术专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一.spring框架概述

1.spring体系架构介绍

2.spring的应用场景

（1）SpringMVC+Spring+Hibernate/Mybatis

一.spring框架概述

Spring是2003年兴起的一个轻量级的Java开源框架，帮助开发团队构建简单、便携、快速和灵活的基于Java的系统，主要用于企业应用领域。这套框架构建的应用有着简单、便携、快速和灵活的特点。与EJB相比，它是一个轻量级的应用开发平台。Spring的用途并不限于服务器端的开发，它可以用于各种Java程序的开发。

简单来说，Spring是一个支持控制反转（IoC）和面向切面（AOP）的轻量级的框架，使你能够用"plain old Java objects"（POJOs，简单普通的Java对象）来构建应用。你可以在Java SE编程模型、Java EE编程模型中应用它。

1.spring体系架构介绍

Spring由20多个模块组成，它们可以分为核心容器（Core Container）、数据访问/集成（Data Access/Integration）、Web、面向切面编程（AOP, Aspect Oriented Programming）、设备（Instrumentation）、消息发送（Messaging）和测试（Test）。体系架构如图1-1所示。

2.spring的应用场景

Spring是一个轻量级解决方法，也是一个构建企业应用的一站式解决方案。Spring也是模块化的，可以根据需求选择所需的模块。同时Spring被设计成非侵入式的，这意味着你的逻辑代码和框架本身没有依赖性。

（1）SpringMVC+Spring+Hibernate/Mybatis

这是现在较为流行的传统Web开发方式，使用SpringMVC作为Web服务框架。

（2）远程服务

现在Web服务器是实现远程服务的API，而不是处理网页请求。最常见的远程服务就是RESTful风格的服务，也是目前非常流行的编程模式，它可以使用jQuery作为客户端，和服务器之间通过AJAX、JSON实现通信和数据交换。

二.控制反转（IOC）和依赖注入(DI)

1.传统方式和IOC例子实现

在讲解控制反转之前，先按照传统方式敲个例子。

(1).创建java web项目：SpringIOC

(2).创建类Persion

public class Persion {
	private Integer pid;
	private String  pname;
	private IdCard  idcard=new IdCard();//自己主动创建
	public Integer getPid() {
		return pid;
	}
	public void setPid(Integer pid) {
		this.pid = pid;
	}
	public String getPname() {
		return pname;
	}
	public void setPname(String pname) {
		this.pname = pname;
	}
	public IdCard getIdcard() {
		return idcard;
	}

}

(3).创建类IdCard

package com.hwadee.spring.entity;
public class IdCard {
	private Integer cid;
	private String cname;
	
	public Integer getCid() {
		return cid;
	}
	public void setCid(Integer cid) {
		this.cid = cid;
	}
	public String getCname() {
		return cname;
	}
	public void setCname(String cname) {
		this.cname = cname;
	}
	
}

(4).创建一个测试类：springIoc

package com.hwadee.spring.test;
import com.hwadee.spring.entity.Persion;
public class springIoc {
	public void traditionalWay() {
		Persion persion = new Persion();
		persion.getIdcard().setCname("信用卡");
		persion.setPid(2011);
		persion.setPname("杨代洪");
		System.out.println("name:" + persion.getPname() + " cname:" + persion.getIdcard().getCname());
	}
}

现在Persion类中包含有一个IdCard类型的一个成员变量idCard。在传统方式的java程序实现中，一个对象需要什么依赖对象都是由自己自行创建。例如Persion类需要IdCard对象的时候，将由Persion对象自行创建一个IdCard对象。程序运行截图如下：

图2-1. 传统方式实现

这种对象依赖的创建方式，运行效果也能达到最初的目标，并且现在在商业项目中也在使用。但是从项目整合设计和松耦合的角度来看，这样做事不合理的。因此我们现在换用控制反转的方式来实现对象依赖的实现。

(1).创建类Persion，注意区分与上面Persion类的不同之处。

/**
 * 
 */
package com.hwadee.spring.entity;

/**
 * @author Administrator
 *
 */
public class Persion {
	private Integer pid;
	private String  pname;
	private IdCard  idcard;//=new IdCard();
	public Integer getPid() {
		return pid;
	}
	public void setPid(Integer pid) {
		this.pid = pid;
	}
	public String getPname() {
		return pname;
	}
	public void setPname(String pname) {
		this.pname = pname;
	}
	public IdCard getIdcard() {
		return idcard;
	}
	public void setIdcard(IdCard idcard) {
		this.idcard = idcard;
	}

}

(2).创建类IdCard,同上。

/**
 * 
 */
package com.hwadee.spring.entity;

/**
 * @author Administrator
 *
 */
public class IdCard {
	private Integer cid;
	private String cname;
	
	public Integer getCid() {
		return cid;
	}
	public void setCid(Integer cid) {
		this.cid = cid;
	}
	public String getCname() {
		return cname;
	}
	public void setCname(String cname) {
		this.cname = cname;
	}
	
}

(3).创建一个容器类SpringContainer。

/**
 * 
 */
import com.hwadee.spring.entity.IdCard;
import com.hwadee.spring.entity.Persion;

/**
 * @author Administrator
 *
 */
public class SpringContainer {//模拟IOC容器
    public Persion getPersion() {
    	Persion persion =new Persion();
    	IdCard idcard=new IdCard();
        persion.setIdcard(idcard);
		return persion;
    }
}

(4).创建测试类


package com.hwadee.spring.test;
import com.hwadee.spring.entity.Persion;

public class springIoc {
	public void container() {
		SpringContainer sc = new SpringContainer();
		Persion persion = sc.getPersion();
		persion.getIdcard().setCname("信用卡");
		persion.setPname("杨代洪");
		System.out.println("姓名:" + persion.getPname() + " 卡类型:" + persion.getIdcard().getCname());

	}
}

现在我们要获取Persion对象，只需通过实例化SpringContainer后的对象的getPersion()方法获取即可。

图2-2 IOC实现

2.控制反转的概念

IoC（Inversion of Control）也称为“控制反转”，它不是什么技术，而是一种设计思想。在Java开发中，IoC意味着将你设计好的对象交给容器控制，而不是传统的由你在对象内部直接控制。IOC是spring的核心功能，通过Ioc容器就可以很放标的管理java bean。在Ioc容器的帮助下，可以实现松耦合，模块分离且共享。

3.传统方式和控制反转的对比

在传统方式的Java程序实现中，一个对象需要什么依赖对象都是由自己主动创建。例如，在类A中需要类B的对象时，将由类A自己主动创建一个类B的对象。

在控制反转的设计思想中，一个对象需要的依赖对象由容器创建，然后容器再将依赖对象赋给它。例如，当类A中需要类B的对象时，A并不会创建一个B对象。现在，类A提供了一个setB的方法，当Container创建好对象后，自动调用类A的setB赋值。

三.Spring IoC入门

1.创建项目

（1）创建一个Java项目。

（2）将Spring的jar文件加入到项目的classpath中。需要导入四个核心（beans、core、context、expression）和一个依赖（commons-loggins...jar）。

导入Spring核心开发包到创建工程：

spring-beans-4.3.4.RELEASE.jar

spring-context-4.3.4.RELEASE.jar

spring-core-4.3.4.RELEASE.jar

spring-expression-4.3.4.RELEASE.jar

还需要下载commons-logging日志包：

commons-logging-1.2.jar

提示：从Spring3.0.X版本开始，asm的jar包已经被合并到spring core包中，不需要再单独下载。

（3）在src中编写Spring配置文件：applicationContext.xml。

2.编写Java类

Spring支持Java类编程，也支持面向接口编程。面向接口编程使用接口分离接口和实现类，其中接口提供了规范声明，实现类提供了具体实现。

public interface UserService {

public void register(User user) throws UserException ;

}

public class UserServiceImpl implements UserService {

@Override

public void register(User user) throws UserException {

//输出用户信息

System.out.println("name:" + user.getName()+"|username:" + user.getUsername());

}

3.传统方式创建实例

在传统方式中，直接new一个对象即可。

public class TestHello {

public static void main(String[] args) {

//传统自己创建

UserService service = new UserServiceImpl();

}

4.IOC方式创建实例

只需要将实现类配置到Spring文件中，当应用程序需要实例对象时，就可以直接从Spring容器中获得。

（1）控制反转（IOC）配置

配置文件名称通常命名为applicationContext.xml，一般放在classpath下（src）。

<?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>

</beans>

（2）从Spring容器获得对象

public void testIoC(){

//1 获得容器

String xmlPath = "applicationContext.xml";

AbstractApplicationContext context = new ClassPathXmlApplicationContext(xmlPath);

//2获得对象。不需要自己new，都是从spring容器获得

UserService userService = context.getBean("userServiceId", UserService.class);

userService.register(user);

//3、关闭Spring的IOC容器

context.close();

}

这里使用了IoC的概念，原本在程序中手动创建UserService对象的控制权交由Spring框架管理。简单说，就是创建UserService对象控制权被反转到了Spring框架。

Gailvain

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录