spring开源框架基础案例入门

爱机车的程序猿

于 2020-04-12 00:03:42 发布

阅读量249

点赞数

文章标签： spring maven java ioc hibernate

本文链接：https://blog.csdn.net/weixin_45067120/article/details/105452962

版权

Spring初级入门

1. 什么是spring，它能够做什么?

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。
Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。
然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。
目的：解决企业应用开发的复杂性
功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能
范围：任何Java应用
简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

SHH2/SSM

1.1 中间层框架、万能胶

   struts2
   spring
   hibernate

1.2 容器框架

     JavaBean        bean（通常翻译）：小豆子，（java里比如）Java对象
     IOC（控制反转或依赖注入）和AOP（面向切面）

先修改pom.xml配置文件及源码：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.zking</groupId>
	<artifactId>test1</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>test1 Maven Webapp</name>
	<url>http://maven.apache.org</url>
	<properties>
		<hibernate.version>5.2.12.Final</hibernate.version>
		<mysql.driver.version>5.1.44</mysql.driver.version>
		<spring.version>5.0.1.RELEASE</spring.version>
		<struts2.version>2.5.13</struts2.version>
		<slf4j.version>1.7.7</slf4j.version>
		<log4j.version>2.9.1</log4j.version>
		<disruptor.version>3.2.0</disruptor.version>
		<junit.version>4.12</junit.version>
		<servlet.version>4.0.1</servlet.version>
		<jstl.version>1.2</jstl.version>
		<standard.version>1.1.2</standard.version>
		<tomcat-jsp-api.version>8.5.20</tomcat-jsp-api.version>
	</properties>

<dependencies>
	<!--1. hibernate相关依赖 -->
	<dependency>
		<groupId>org.hibernate</groupId>
		<artifactId>hibernate-core</artifactId>
		<version>${hibernate.version}</version>
	</dependency>
	<dependency>
		<groupId>org.hibernate</groupId>
		<artifactId>hibernate-c3p0</artifactId>
		<version>${hibernate.version}</version>
	</dependency>
	<dependency>
		<groupId>org.hibernate</groupId>
		<artifactId>hibernate-ehcache</artifactId>
		<version>${hibernate.version}</version>
	</dependency>
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>${mysql.driver.version}</version>
	</dependency>

	<!--2. spring相关(5.0.1.RELEASE) -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-orm</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-web</artifactId>
		<version>${spring.version}</version>
	</dependency>

	<!-- aop -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aop</artifactId>
		<version>${spring.version}</version>
	</dependency>

	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aspects</artifactId>
		<version>${spring.version}</version>
	</dependency>

	<dependency>
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjrt</artifactId>
		<version>1.6.11</version>
	</dependency>
	<dependency>
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjweaver</artifactId>
		<version>1.6.11</version>
	</dependency>
	<dependency>
		<groupId>cglib</groupId>
		<artifactId>cglib</artifactId>
		<version>2.1_3</version>
	</dependency>
	<!-- end -->



	<!--3. struts2相关(2.5.13) -->
	<dependency>
		<groupId>org.apache.struts</groupId>
		<artifactId>struts2-core</artifactId>
		<version>${struts2.version}</version>
		<exclusions>
			<exclusion>
				<artifactId>commons-io</artifactId>
				<groupId>commons-io</groupId>
			</exclusion>
			<exclusion>
				<artifactId>log4j-api</artifactId>
				<groupId>org.apache.logging.log4j</groupId>
			</exclusion>
		</exclusions>
	</dependency>
	<dependency>
		<groupId>org.apache.struts</groupId>
		<artifactId>struts2-spring-plugin</artifactId>
		<version>${struts2.version}</version>
		<exclusions>
			<exclusion>
				<artifactId>spring-web</artifactId>
				<groupId>org.springframework</groupId>
			</exclusion>
			<exclusion>
				<artifactId>spring-beans</artifactId>
				<groupId>org.springframework</groupId>
			</exclusion>
			<exclusion>
				<artifactId>spring-context</artifactId>
				<groupId>org.springframework</groupId>
			</exclusion>
			<exclusion>
				<artifactId>spring-core</artifactId>
				<groupId>org.springframework</groupId>
			</exclusion>
		</exclusions>
	</dependency>

	<!--4. log配置：Log4j2 + Slf4j -->
	<!-- slf4j核心包 -->
	<dependency>
		<groupId>org.slf4j</groupId>
		<artifactId>slf4j-api</artifactId>
		<version>${slf4j.version}</version>
	</dependency>
	<dependency>
		<groupId>org.slf4j</groupId>
		<artifactId>jcl-over-slf4j</artifactId>
		<version>${slf4j.version}</version>
		<scope>runtime</scope>
	</dependency>

	<!--用于与slf4j保持桥接 -->
	<dependency>
		<groupId>org.apache.logging.log4j</groupId>
		<artifactId>log4j-slf4j-impl</artifactId>
		<version>${log4j.version}</version>
		<exclusions>
			<exclusion>
				<artifactId>slf4j-api</artifactId>
				<groupId>org.slf4j</groupId>
			</exclusion>
		</exclusions>
	</dependency>

	<!--核心log4j2jar包 -->
	<dependency>
		<groupId>org.apache.logging.log4j</groupId>
		<artifactId>log4j-api</artifactId>
		<version>${log4j.version}</version>
	</dependency>
	<dependency>
		<groupId>org.apache.logging.log4j</groupId>
		<artifactId>log4j-core</artifactId>
		<version>${log4j.version}</version>
	</dependency>

	<!--web工程需要包含log4j-web，非web工程不需要 -->
	<dependency>
		<groupId>org.apache.logging.log4j</groupId>
		<artifactId>log4j-web</artifactId>
		<version>${log4j.version}</version>
		<scope>runtime</scope>
	</dependency>
	<!--需要使用log4j2的AsyncLogger需要包含disruptor -->
	<dependency>
		<groupId>com.lmax</groupId>
		<artifactId>disruptor</artifactId>
		<version>${disruptor.version}</version>
	</dependency>

	<!--5. other -->
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>${junit.version}</version>
		<scope>test</scope>
	</dependency>
	<dependency>
		<groupId>javax.servlet</groupId>
		<artifactId>javax.servlet-api</artifactId>
		<version>${servlet.version}</version>
		<scope>provided</scope>
	</dependency>

	<!--6. jstl -->
	<dependency>
		<groupId>javax.servlet.jsp.jstl</groupId>
		<artifactId>jstl</artifactId>
		<version>${jstl.version}</version>
	</dependency>
	<dependency>
		<groupId>taglibs</groupId>
		<artifactId>standard</artifactId>
		<version>${standard.version}</version>
	</dependency>

	<!-- 7. jsp自定义标签依赖 (必须与tomcat的版本一致) -->
	<dependency>
		<groupId>org.apache.tomcat</groupId>
		<artifactId>tomcat-jsp-api</artifactId>
		<version>${tomcat-jsp-api.version}</version>
		<scope>provided</scope>
	</dependency>
</dependencies>
<build>
	<finalName>sp01</finalName>
	<plugins>
		<!--第一步就是配置maven-compiler-plugin插件 -->
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-compiler-plugin</artifactId>
			<version>3.7.0</version>
			<configuration>
				<source>1.7</source>
				<target>1.7</target>
				<encoding>UTF-8</encoding>
			</configuration>
		</plugin>
	</plugins>
</build>
</project>

2. 什么是控制反转(或依赖注入)

控制反转(IoC=Inversion of Control)IoC，用白话来讲，就是由容器控制程序之间的（依赖）关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在：(依赖)控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。
IoC还有一个另外的名字：“依赖注入 (DI=Dependency Injection)” ，即由容器动态的将某种依赖关系注入到组件之中

案例：
实现Spring的IoC

在这里插入图片描述
IOC/DI:(IOC控制反转或DI依赖注入)
将以前由程序员实例化对象/赋值的工作交给了spring处理

##必须要记的

3. 如何在spring当中定义和配置一个JavaBean(使用无参构造方法+set方法创建一个JavaBean)

3.1 id：在容器中查找Bean的id(唯一、且不能以/开头)

3.2 class：bean的完整类名（反射机制实例化对象）

3.3 name：在容器中查找Bean的名字(唯一、允许以/开头、允许多个值，多个值之间用逗号或空格隔开)

在这里插入图片描述

3.4 scope:(singleton | prototype)默认是singleton

3.4.1 singleton(单例模式)：在每个Spring IoC容器中一个bean定义对应一个对象实例

3.4.2 prototype(多例模式)：一个bean定义对应多个对象实例

注1： struts2的Action请使用多例模式，因为Action要用来接收参数
在这里插入图片描述

3.4 abstract：将一个bean定义成抽象bean(抽象bean是不能实例化的),抽象类一定要定义成抽象bean,非抽象类也可以定义成抽象bean

3.5 parent：指定一个父bean(必须要有继承关系才行)

在这里插入图片描述

3.6 init-method：指定bean的初始化方法

在这里插入图片描述

3.7 constructor-arg：使用有参数构造方法创建javaBean

在这里插入图片描述

4. 简单属性的配置:

8+1+3
8基础数据+String+3个sql
java.util.Date
java.sql.Date
java.sql.Time
java.sql.Timestamp
通过标签赋值即可

5. 复杂属性的配置

5.1 JavaBean
ref bean=""
在这里插入图片描述
5.2 List或数组

5.3 Map

5.4 Properties

前面案例Student继承了Person源码

package com.zking.test.p1;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;

public class Student extends Person {
	private String sid;
	
private Address address;

private Integer[] arr;

private List  list;

private Map  map;

private Properties properties;

public Student() {
}


public String getSid() {
	return sid;
}

public void setSid(String sid) {
	this.sid = sid;
}
public Address getAddress() {
	return address;
}

public void setAddress(Address address) {
	this.address = address;
}

public Integer[] getArr() {
	return arr;
}

public void setArr(Integer[] arr) {
	this.arr = arr;
}


public List getList() {
	return list;
}


public void setList(List list) {
	this.list = list;
}


public Map getMap() {
	return map;
}


public void setMap(Map map) {
	this.map = map;
}


public Properties getProperties() {
	return properties;
}


public void setProperties(Properties properties) {
	this.properties = properties;
}


@Override
public String toString() {
	return "Student [sid=" + sid + ", address=" + address + ", arr=" + Arrays.toString(arr) + ", list=" + list
			+ ", map=" + map + ", properties=" + properties + ", idcard=" + getIdcard() + "]";
}


}

Sprin.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:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context" 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/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
		<!-- 配置一个javabean对象 -->
	<bean id="helloBean" scope="singleton" init-method="init"  name="a b /c" class="com.zking.test.Model.HelloBean">
		<property name="name">
			<value>王五</value>
		</property>
	</bean>

<bean id="zdm" scope="singleton" class="com.zking.test.Model.HelloBean">
	<!-- 有参构造方法第一列 -->
	<constructor-arg index="0">
		<value>大明</value>
	</constructor-arg>
</bean>

<bean id="person" class="com.zking.test.p1.Person" abstract="true">
	<property name="idcard">
		<value>4325XXXXXXXXXXXXXXXX</value>
	</property>
</bean>

<bean id="e" class="com.zking.test.p1.Employee" parent="person">
	<property name="eid">
		<value>001</value>
	</property>
</bean>

<bean id="s" class="com.zking.test.p1.Student" parent="person">
	<property name="sid">
		<value>1</value>
	</property>
	<property name="address">
		<ref bean="addr"></ref>
	</property>
	<property name="arr">
		<list>
			<value>111</value>
			<value>222</value>
			<value>333</value>
		</list>
	</property>
	<property name="list">
		<list>
			<value>aaa</value>
			<value>bbb</value>
			<value>ccc</value>
		</list>
	</property>
	<property name="map">
		<map>
			<entry>
				<key>
					<value>张三</value>
				</key>
				<value>123</value>
			</entry>
			<entry>
				<key>
					<value>王五</value>
				</key>
				<value>456</value>
			</entry>
			<entry>
				<key>
					<value>李四</value>
				</key>
				<value>789</value>
			</entry>
		</map>
	</property>
	<property name="properties">
		<props>
			<prop key="P1">数值1</prop>
			<prop key="P2">数值2</prop>
		</props>
	</property> 
</bean>

<bean id="addr" class="com.zking.test.p1.Address">
	<property name="city">
		<value>娄底</value>
	</property>
</bean>

<!-- <import resource="spring-order.xml"/>
<import resource="spring-sys.xml"/> -->
</beans>

Demol测试类源码:

package com.zking.test.p1;

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

import com.zking.test.Model.HelloBean;

public class Demo1 {
	
	public static void main(String[] args) {
		//Application应用
		//Context容器/环境
		//不合法的状态，beanFactory没有初始化或者关闭，在上下文中刷新会导致报错。
	ApplicationContext  applicationContext = new ClassPathXmlApplicationContext("classpath:spring.xml");
	//实例化对象HelloBean指向spring.xml里id名
//	HelloBean bean = (HelloBean) applicationContext.getBean("/c");
//	//spring控制反转
//	bean.hello();
//	//实例化对象HelloBean指向spring.xml里id名
//	HelloBean zdm = (HelloBean) applicationContext.getBean("zdm");
//	//spring控制反转
//	zdm.hello();
	
//	Student s = (Student) applicationContext.getBean("s");
//	Employee e = (Employee) applicationContext.getBean("e");
//	System.out.println("student："+s.getSid()+"  employee："+e.getEid()+"  Person："+s.getIdcard());

Student s = (Student) applicationContext.getBean("s");
System.out.println(s);
}
}

6. 多配置文件(项目中用得到)

//把spring.xml比作为组长
spring.xml
//组员写的xml文件

 <import resource="spring-a.xml"/>

//组内成员
spring-a.xml/spring-b.xml/spring-c.xml
在这里插入图片描述

通过此案例，我们可以搞清楚spring与web项目的一个集成原理

7. spring与web项目的集成

WEB项目如何读取spring上下文
通过监听器实现SpringtListener源码

   package com.zking.test.Util;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

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

/**
 * 监听器
 * 读取Spring上下文的
 * @author zjjt
 *
 */
public class SpringListener implements ServletContextListener {
	
	private String contextConfigLocation="classpath:spring.xml";

	@Override
	public void contextDestroyed(ServletContextEvent sce) {
	}

	@Override
	public void contextInitialized(ServletContextEvent sce) {
	System.out.println("读取Spring上下文，并保存到application作用域里面");
	ServletContext application = sce.getServletContext();
	// 指定配置文件的路径
	String contextConfigLocation = application.getInitParameter("contextConfigLocation");
	if (null != contextConfigLocation && !"".equals(contextConfigLocation)) {
		this.contextConfigLocation = contextConfigLocation;
	}
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext(contextConfigLocation);
	SpringUtil.setContext(application, applicationContext);
}

}

再写一个SpringUtil作用域源码:

package com.zking.test.Util;

import javax.servlet.ServletContext;

import org.springframework.context.ApplicationContext;

/**
 * 作用域
 * @author zjjt
 *
 */
public class SpringUtil {

public static final String CONTEGT_KEY = "com.zking.test.Util.SpringUtil";

public SpringUtil() {
}
public static void setContext(ServletContext application,ApplicationContext applicationContext) {
	application.setAttribute(CONTEGT_KEY, applicationContext);
}
public static ApplicationContext getContext(ServletContext application) {
	return (ApplicationContext) application.getAttribute(CONTEGT_KEY);
}

}

contextConfigLocation:classpath:applicationContext-*.xml
在这里插入图片描述

启动Tomcat/发布web项目

爱机车的程序猿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring开源框架基础案例入门

Spring初级入门1. 什么是spring，它能够做什么?1.1 中间层框架、万能胶1.2 容器框架2. 什么是控制反转(或依赖注入)3. 如何在spring当中定义和配置一个JavaBean(使用无参构造方法+set方法创建一个JavaBean)3.1 id：在容器中查找Bean的id(唯一、且不能以/开头)3.2 class：bean的完整类名（反射机制实例化对象）3.3 name：在容器中...
复制链接

扫一扫