java之Spring

最新推荐文章于 2024-05-19 08:15:00 发布

「已注销」

最新推荐文章于 2024-05-19 08:15:00 发布

阅读量247

点赞数

分类专栏： Spring 文章标签： java

本文链接：https://blog.csdn.net/weixin_49588744/article/details/107704605

版权

Spring

1. 什么是Spring?
答:Spring是一个开源分层的JavaSE/EE一站式服务轻量级开源框架，解决业务逻辑层service与web层和数据访问层之间的松耦合问题。

2. Spring的结构组成
答:
在这里插入图片描述
从下往上test、core容器、aop(面向切面编程)、web、data 、access
1.test部分只有一个模块：
spring-test：spring测试，提供junit与mock测试功能
spring-context-support：spring额外支持包，比如邮件服务、视图解析等
它们的依赖关系
在这里插入图片描述
2.core部分包含4个模块
spring-core：依赖注入IoC与DI的最基本实现
spring-beans：Bean工厂与bean的装配
spring-context：spring的context上下文即IoC容器
spring-expression：spring表达式语言
它们的完整依赖关系

3.aop部分包含4个模块
spring-aop：面向切面编程
spring-aspects：集成AspectJ
spring-instrument:提供一些类级工具支持和ClassLoader级的实现，用于服务器spring-instrument-tomcat:针对tomcat的instrument实现
它们的依赖关系
在这里插入图片描述
4.web部分包含4个模块
spring-web：基础web功能，如文件上传
spring-webmvc：mvc实现
spring-webmvc-portlet：基于portlet的mvc实现
spring-struts：与struts的集成，不推荐，spring4不再提供
它们的依赖关系

5.data access部分包含5个模块
spring-jdbc：jdbc的支持
spring-tx：事务控制
spring-orm：对象关系映射，集成orm框架
spring-oxm：对象xml映射
spring-jms：java消息服务
它们的依赖关系
在这里插入图片描述
3. Spring的优点
答:
1.方便解耦，简化开发：Spring是一个超级工厂（超级容器），可以将对象的创建和依赖关系交给Spring工厂去管理。
2.AOP编程：Spring提供面向切面编程，可以方便的对程序进行运行监控、权限验证等操作。
3.声明事务：只需要通过配置就可以完成对事务的管理，不需要手动编程。
4.方便测试：Spring支持junit4，可以通过Spring注解方式测试程序。
5.方便集成各种框架：Spring支持各种开源框架的集成。例如（struts、Hibernate、MyBaties等）
6.降低JavaEE API的使用难度： Spring对JavaEE开发中非常难用的API进行封装，使这些开发API应用难度降低。

4. Spring的核心技术
答:
1.IoC（Inverse of Control 反转控制）：将java对象创建和维护权利交由Spring工厂进行管理和维护。
2.DI(依赖注入)：将某一个java类中的依赖对象快速的添加到另一个java类中。
3.AOP（Aspect Oriented Programming 面向切面编程)，基于动态代理的功能增强方([给自己的程序中添加一些系统需求的处理(日志管理，数据的安全性检查…))。
4.事务管理的相关操作。
5.Spring整合/管理其他各层的框架(Spring集成web层SpringMVC/Spring整合数据访问层MyBatis)。

5. Spring的IoC（Inverse of Control 反转控制）
答:IoC（Inverse of Control 反转控制）：将java对象创建和维护权利交由Spring工厂进行管理和维护。
5.1.在没有使用IoC技术的时候，java对象的创建和维护权利是由程序开发者自己来创建和维护。

package com.click369.javabean;
public class StudentBean {
   
    private  int stuid;
    private  String  stuname;
    private  int stuage;
    
    public StudentBean(){
   }
    
    public StudentBean(int stuid,String stuname,int stuage){
   
    	this.stuid=stuid;
    	this.stuname=stuname;
    	this.stuage=stuage;
    }
    
	public int getStuid() {
   
		return stuid;
	}
	public void setStuid(int stuid) {
   
		this.stuid = stuid;
	}
	public String getStuname() {
   
		return stuname;
	}
	public void setStuname(String stuname) {
   
		this.stuname = stuname;
	}
	public int getStuage() {
   
		return stuage;
	}
	public void setStuage(int stuage) {
   
		this.stuage = stuage;
	}
	@Override
	public String toString() {
   
		return "stuid=="+stuid+"  stuname=="+stuname+" stuage=="+stuage;
	}
}

@Test
	public  void test1(){
   
		//自己new的java对象，java对象的创建是程序开发者自己创建维护
		StudentBean stu=new StudentBean(1001,"zhangsan",23);
		System.out.println(stu.toString());
	}

使用Spring框架

1.	导入依赖包
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.1.5.RELEASE</version>
</dependency>

在这里插入图片描述
通过在Spring的配置文件中通过元素配置由Spring工厂所要创建的java对象。
在工程的src/main/resources下创建一个(applicationContext.xml)文件，spring核心配置文件。

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

例如：

<bean id="student" class="com.click369.javabean.StudentBean"></bean>

从spring工厂创建众多对象中选出自己要用的对象首先得到spring工厂对象，然后通过这个工厂对象提供的方法getBean(“”)将自己需要的对象得到。
spring工厂对象:
1.BeanFactory接口----Spring工厂对象
2.ApplicationContex接口------Spring工厂对象
ApplicationContext接口这个Spring工厂对象是BeanFactory接口的子接口。
在这里插入图片描述

如何创建Spring工厂对象？
1.ClassPathXmlApplicationContext类 – new ClassPathXmlApplicationContext()可以创建出BeanFactory接口对象/ApplicationContext对象
表示：通过查找类路径加载一个Xml文件创建Spring工厂对象。(相对路径下查找Spring核心配置文件)
2.FileSystemXmlApplicationContext类 —new FileSystemXmlApplicationContext可以创建出BeanFactory接口对象/ApplicationContext对象
表示：通过在系统文件类路径中加载一个Xml文件创建Spring工厂对象。(绝对路径下查找Spring核心配置文件)
例如：

//创建Spring工厂对象--BeanFactory接口
//1.通过查找类路径加载一个Xml文件创建Spring工厂对象。
BeanFactory  beanFactory1=new ClassPathXmlApplicationContext("applicationContext.xml");
//2.通过在系统文件类路径中加载一个Xml文件创建Spring工厂对象。
BeanFactory  beanFactory2=new FileSystemXmlApplicationContext("F:\\20200730\\Spring\\applicationContext.xml");
//创建Spring工厂对象--ApplicationContex接口
//1.通过查找类路径加载一个Xml文件创建Spring工厂对象。
ApplicationContext  ac1=new ClassPathXmlApplicationContext("applicationContext.xml");
//2.通过在系统文件类路径中加载一个Xml文件创建Spring工厂对象。
ApplicationContext  ac2=new FileSystemXmlApplicationContext("F:\\20200730\\Spring\\applicationContext.xml");

在创建Spring工厂对象的时候需要什么？
需要一个Xml文件【Spring的核心配置文件】
通过Spring工厂对象，调用getBean()得到自己需要的java对象

//StudentBean stu=(StudentBean)ac1.getBean("student");
StudentBean stu=ac1.getBean(StudentBean.class);
stu.setStuid(1001);
stu.setStuname("zhangsan");
stu.setStuage(23);
stu.setStuaddress("西安");
System.out.println(stu.toString());

IOC[控制反转]–将java对象的创建和维护权利，从开发者自己的手中，转移Spring身上，这种对象的创建和维护权利的转移就叫控制反转。

6. Bean实例化4种方式
答:
6.1无参数构造方法（开发最常用）

package com.click369.javabean;
public class StudentBean {
   
    private  int stuid;
    private  String  stuname;
    private  int stuage;
    
public StudentBean(){
   }
.............
}

编写Spring的配置文件：(applicationContext.xml/自己起名)放在src/main/resources下

<!-- 无参数构造方法实例化bean -->
<!-- id:对象名称 -->
<!-- class:被创建对象的java类的包名+类名 -->
<bean id="stu" class="com.click369.javabean.StudentBean"></bean>

测试
//创建Spring工厂对象
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
//通过getBean方法从Spring工厂对象中得到需要的java类对象
StudentBean  stu= (StudentBean)applicationContext.getBean("stu");
//使用由Spring工厂对象实例化好的java对象
stu.setStuid(1001);
stu.setStuname("lisi");
stu.setStuage(24);
System.out.println("stu=="+stu.toString());

6.2静态工厂方法实例化bean
静态工厂方法：在一个类中书写静态的方法，这个方法返回某个Bean的对象（在方法中创建Bean的对象）。

实体类：
package com.click369.javabean;
public class StudentBean {
   
    private  int stuid;
    private  String  stuname;
    private  int stuage;
public StudentBean(){
   }
.............
}

创建一个静态工厂方法类，提供一个静态方法，让这个静态方法返回一个实体类的对象。

package com.click369.javabean;
/**
 * 静态工厂方法类
 * @author Administrator
 *
 */
public class StaticFactoryMethodClass {
   
	/**
	 * 静态方法，让这个静态方法返回一个实体类的对象
	 * @return
	 */
	public  static  StudentBean   getStaticStudentBean(){
   
		return new StudentBean();
	}
}

编写Spring配置

<!-- 静态工厂方法实例化bean的配置 -->
	<!-- id:对象名称 -->
	<!-- factory-method:配置静态工厂方法 -->
	<!-- class:配置静态工厂方法类【包名+类名】 -->
	<bean id="student" factory-method="getStaticStudentBean" class="com.click369.javabean.StaticFactoryMethodClass"></bean>

测试代码：

 ApplicationContext  applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
StudentBean  stu= applicationContext.getBean(StudentBean.class);
stu.setStuid(1002);
stu.setStuname("wangwu");
stu.setStuage(25);
System.out.println("stu=="+stu.toString());

6.3实例工厂方法实例化bean
实体类：

package com.click369.javabean;
public class StudentBean {
   
    private  int stuid;
    private  String  stuname;
    private  int stuage;  
public StudentBean(){
   }
.............
}

创建一个工厂类，提供实例方法，这个实例方法返回java实体类的对象。

package com.click369.javabean;
/**
 * 工厂类
 * @author Administrator
 *
 */
public class StudentFactory {
   
    /**
     * 实例方法，返回实体类对象
     * @return
     */
	public  StudentBean getStudentBean(){
   
		return new StudentBean();
	}
}

Spring配置文件的编写：

<!-- 实例工程方法实例化bean的配置 -->
	<!-- 创建实例工厂类对象 -->
	<bean id="studentFactory" class="com.click369.javabean.StudentFactory"></bean>
	<!-- 配置得到实体类对象 -->
	<!-- id:对象名称 -->
	<!-- factory-bean:实例工厂类对象 -->
	<!-- factory-method:实例工厂类中创建实体类的方法 -->
	<bean id="student" factory-bean="studentFactory" factory-method="getStudentBean"></bean>

测试：

ApplicationContext  applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
StudentBean  stu= applicationContext.getBean(StudentBean.class);
stu.setStuid(1002);
stu.setStuname("wangwu");
stu.setStuage(25);
System.out.println("stu=="+stu.toString());

6.4FactoryBean接口方式实例化bean
FactoryBean是Spring提供的接口，专门用于对bean进行初始化操作的。
如果bean需要使用这种方式进行初始化，那么需要定义类实现这个FactoryBean接口，在实现类中复写getObject的方法。
实体类：

package com.click369.javabean;
public class StudentBean {
   
    private  int stuid;
    private  String  stuname;
    private  int stuage;  
public StudentBean(){
   }
.............
}

创建一个类，实现FactoryBean接口，重写getObject的方法，返回实体类对象。

package com.click369.factory;
import org.springframework.beans.factory.FactoryBean;
import com.click369.javabean.StudentBean;
public class CreateObject implements FactoryBean<StudentBean>{
   
	@Override
	public StudentBean getObject() throws Exception {
   
		return new StudentBean();
	}
	@Override
	public Class<?> getObjectType() {
   
		return StudentBean.class;
	}
}

Spring配置文件：

<!--

最低0.47元/天解锁文章

「已注销」

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java之Spring

Spring1. 什么是Spring?答:Spring是一个开源分层的JavaSE/EE一站式服务轻量级开源框架，解决业务逻辑层service与web层和数据访问层之间的松耦合问题。2. Spring的结构组成答:从下往上test、core容器、aop(面向切面编程)、web、data 、access1.test部分只有一个模块：spring-test：spring测试，提供junit与mock测试功能spring-context-support：spring额外支持包，比如邮件服务、视图
复制链接

扫一扫