一、 什么是spring,它能够做什么?
Spring是一个开源框架,它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。
Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。
然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益。
目的:解决企业应用开发的复杂性
功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能
范围:任何Java应用
简单来说,Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
通俗来讲,其他框架能做的,spring也能做,spring有全家桶这一概念,因为它旗下有很多框架,能代替很多框架(如下框架今年来慢慢被spring所取代)
架构方案层面
spring struts Hibernate
spring springmvc mybatis
springboot dubbox
SpringCloud技术层面
安全技术方面:Shiro springSecurity
数据库层面:hibernate、mybatis SpringDataJpa
消息中间件:activityMQ、RabbitMQ、kaffka spring..MQ中间层框架、万能胶 容器框架
struts2 JavaBean 项目中的一个个类
spring IOC和AOP
hibernate
如图:便于理解spring框架
spring包含的模块
2、什么是控制反转(或依赖注入)
控制反转(IoC=Inversion of Control)IoC:
用白话来讲,就是由容器控制程序之间的(依赖)关系,而非传统实现中,由程序代码直接操控。这也就是所谓“控制反转”的概念所在:(依赖)控制权由应用代码中转到了外部容器,控制权的转移,是所谓反转。
IoC还有一个另外的名字:“依赖注入 (DI=Dependency Injection)” ,即由容器动态的将某种依赖关系注入到组件之中通俗理解:
作用:创建对象,处理对象的依赖关系。
使用IOC:比如我们去找房子,我们不需要自己一个一个去看,去找,IOC相当于一个中介,管理着很多房子,我们提出自己的需求就行,然后中介给我们相对应的房子,我们直接使用就行。
一、IOC的具体体现
1/1,导入jar包,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.lgs</groupId> <artifactId>T269LGS_spring</artifactId> <packaging>war</packaging> <version>0.0.1-SNAPSHOT</version> <name>T269LGS_spring Maven Webapp</name> <url>http://maven.apache.org</url> <properties> <spring.version>5.0.1.RELEASE</spring.version> <javax.servlet.version>4.0.0</javax.servlet.version> <junit.version>4.12</junit.version> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> <!-- 2、导入spring依赖 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>${spring.version}</version> </dependency> <!-- 5.1、junit --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>${junit.version}</version> <scope>test</scope> </dependency> <!-- 5.2、servlet --> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>${javax.servlet.version}</version> <scope>provided</scope> </dependency> </dependencies> <build> <finalName>T269LGS_spring</finalName> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.7.0</version> <configuration> <source>1.8</source> <target>1.8</target> <encoding>UTF-8</encoding> </configuration> </plugin> </plugins> </build> </project>
1/2,创建spring的配置文件spring-context.xml文件
1/3,写一个接口类UserBiz.java
package com.lgs.ioc.biz; public interface UserBiz { // 上传功能 public void upload(); }
IOC展示分析:
假设做一个上传功能
现在提出整改要求:1,限定上传文件大小 2,限定上传文件类别现在有几个版本的要求:
action1 不需要加限制 action2 需要加限制假设你有开发一个游戏,原版本action1不需要加限制,当你开发出了一个新功能,需要更新版本action2,如果更新给游戏其他功能带来问题,我们需要要回到上一个版本,这是IOC的功能就体现出来了
总结:1.更新版本需要改动原有代码 2.相关调用此方法的模块伴随着巨大风险
1/4,写UserBiz.xml的实现类UserBizImpl1.java实现基础功能
package com.lgs.ioc.biz.impl; import com.lgs.ioc.biz.UserBiz; public class UserBizImpl1 implements UserBiz{ /** * 假设做一个上传功能 * 现在提出整改要求: * 1,限定上传文件大小 2,限定上传文件类别 * * 现在有几个版本的要求: * action1 不需要加限制 * action2 需要加限制 * * 假设你有开发一个游戏,原版本action1不需要加限制,当你开发出了一个新功能,需要更新版本action2, * 如果更新给游戏其他功能带来问题,我们需要要回到上一个版本,这是IOC的功能就体现出来了 * * 总结:1.更新版本需要改动原有代码 2.相关调用此方法的模块伴随着巨大风险 * */ public void upload() { System.out.println("按要求开发功能"); } }
1/5,写UserBiz.xml的实现类UserBizImpl2.java实现优化性能功能
package com.lgs.ioc.biz.impl; import com.lgs.ioc.biz.UserBiz; public class UserBizImpl2 implements UserBiz{ public void upload() { System.out.println("做条件判断,加限定,不符合要求的不给予上传"); System.out.println("按要求开发功能"); } }
1/6,UserAction1、UserAction2、UserAction3 三个类是一样的,方便测试
package com.lgs.ioc.web; import com.lgs.ioc.biz.UserBiz; import com.lgs.ioc.biz.impl.UserBizImpl1; public class UserAction1 { private UserBiz userBiz; public UserBiz getUserBiz() { return userBiz; } public void setUserBiz(UserBiz userBiz) { this.userBiz = userBiz; } public void upload() { userBiz.upload(); } public static void main(String[] args) { UserAction1 userAction = new UserAction1(); userAction.upload(); } }
1/7、PersonAction
package com.lgs.ioc.web; import com.lgs.ioc.biz.UserBiz; public class PersonAction { private UserBiz userBiz; public UserBiz getUserBiz() { return userBiz; } public void setUserBiz(UserBiz userBiz) { this.userBiz = userBiz; } public void upload() { userBiz.upload(); } public static void main(String[] args) { PersonAction personAction = new PersonAction(); personAction.upload(); } }
1/8、spring-context配置文件
<?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" 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"> <!-- 本文件中配置整个项目中包含的所有的JavaBean,目的在于spring项目的统一管理 --> <!-- <bean name="userBiz1" class="com.lgs.ioc.biz.impl.UserBizImpl1"></bean> --> <bean name="userBiz2" class="com.lgs.ioc.biz.impl.UserBizImpl1"></bean> <bean name="userBiz1" class="com.lgs.ioc.biz.impl.UserBizImpl2"></bean> <bean name="personAction" class="com.lgs.ioc.web.PersonAction"> <property name="userBiz" ref="userBiz2"></property> </bean> <bean name="userAction1" class="com.lgs.ioc.web.UserAction1"> <property name="userBiz" ref="userBiz1"></property> </bean> <bean name="userAction2" class="com.lgs.ioc.web.UserAction2"> <property name="userBiz" ref="userBiz1"></property> </bean> <bean name="userAction3" class="com.lgs.ioc.web.UserAction3"> <property name="userBiz" ref="userBiz1"></property> </bean> </beans>
1/9、测试IocTest
package com.lgs.ioc.test; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.lgs.ioc.web.PersonAction; import com.lgs.ioc.web.UserAction1; import com.lgs.ioc.web.UserAction2; import com.lgs.ioc.web.UserAction3; public class IocTest { public static void main(String[] args) { // 建模 ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml"); // 可以得到任意bena PersonAction personAction = (PersonAction) applicationContext.getBean("personAction"); personAction.upload(); UserAction1 userAction1 = (UserAction1) applicationContext.getBean("userAction1"); userAction1.upload(); UserAction2 userAction2 = (UserAction2) applicationContext.getBean("userAction2"); userAction2.upload(); UserAction3 userAction3 = (UserAction3) applicationContext.getBean("userAction3"); userAction3.upload(); } }
运行结果:
如果需要要求要userBizImpl1的版本:那么只需要在此处改一下就好了
运行结果:
总结:
假如我们要换一个功能,则需要修改很多地方,很繁琐,IOC解决了此问题,userAction和OrderAction是实现不同的功能,都用了UserBiz属性去调用后台代码的方法,只需要在配置的时候进行修改即可。
解决以下两点风险:
1.更新版本需要改动原有代码 2.相关调用此方法的模块伴随着巨大风险
二,spring传参
IOC的传参的三种方式
1、ser传参
2、构造传参
3、自动装配(基本不用)
1、ser传参 新建实体类,自定义传参(一定要get/set方法)
输出方法:
spring-context配置文件
<bean name="paramAction" class="com.lgs.ioc.web.ParamAction"> <property name="name" value="鲁迅"></property> <property name="age" value="34"></property> <property name="hobby"> <list> <value>学医</value> <value>白话文学</value> <value>作家</value> </list> </property> </bean>
调用:
运行结果:
2、构造传参
建立有参无参构造
spring-context配置文件
<bean name="paramAction" class="com.lgs.ioc.web.ParamAction"> <constructor-arg name="name" value="武则天"></constructor-arg> <constructor-arg name="age" value="22"></constructor-arg> <constructor-arg name="hobby"> <list> <value>跳舞</value> <value>唱歌</value> <value>当皇帝</value> </list> </constructor-arg> </bean>
调用:
运行结果:
三、spring与Tomcat整合
为什么要利用Tomcat整合?
每一次在网页上发送一个请求时,都要访问后台,然后建模,我们不可能每次都要建模,建模也是非常消耗性能的,所以我们现在的处理方式就是利用Tomcat整
3/1、建立监听器 SpringLoaderListener
package com.lgs.ioc.listener; import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; import org.springframework.context.support.ClassPathXmlApplicationContext; public class SpringLoaderListener implements ServletContextListener{ public void contextInitialized(ServletContextEvent sce) { System.out.println("监听器方法执行》》》》"); ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml"); sce.getServletContext().setAttribute("SpringContext", applicationContext); } }
3/2、配置监听器 web.xml
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1"> <display-name>Archetype Created Web Application</display-name> <listener> <listener-class>com.lgs.ioc.listener.SpringLoaderListener</listener-class> </listener> </web-app>
3/3、servlet进行测试 Userservlet
package com.lgs.ioc.servlet; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.springframework.context.ApplicationContext; import com.lgs.ioc.web.ParamAction; @WebServlet("/user") public class Userservlet extends HttpServlet{ protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { ApplicationContext springContext = (ApplicationContext) req.getServletContext().getAttribute("SpringContext"); ParamAction paramAction = (ParamAction) springContext.getBean("paramAction"); paramAction.execute(); } }
测试结果:
OK! 到这就结束了,希望能帮到你!!