SSM-Spring快速入门(基于maven)

于 2022-06-11 22:12:02 发布
阅读量117 收藏
点赞数
分类专栏： Java学习 文章标签： spring maven java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43556844/article/details/125239483
版权

Spring IoC&DI

  • 开发流程
    （1）导入Spring开发的基本包坐标
    <properties>
<spring.version>5.0.5.RELEASE</spring.version>
</properties>
<!--导入spring的context坐标，context依赖core、beans、expression-->
<dependencies>
  <dependency> 
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
  </dependency>
</dependencies>
    （2）编写Dao接口和实现类
    public interface UserDao { 
  	public void save();
}
public class UserDaoImpl implements UserDao { 
    @Override 
    public void save() {
   		System.out.println("UserDao save method running....");
	}
}
    （3）创建Spring核心配置文件(在类路径下(resources)创建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"
xsi:schemaLocation="
  http://www.springframework.org/schema/beans        
http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>
    （4）在 Spring 配置文件中配置 UserDaoImpl
    <?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 id="userDao" class="com.demo.dao.impl.UserDaoImpl"></bean>
</beans>
    （5）使用 Spring 的 API 获得 Bean 实例
    	@Test
	public void test1(){
		ApplicationContext applicationContext = new 
      		ClassPathXmlApplicationContext("applicationContext.xml");
    	UserDao userDao = (UserDao) applicationContext.getBean("userDao"); 
		userDao.save();
	}
  • Spring配置文件介绍
    （1）Bean标签基本配置
    配置将对象交由Spring来创建。
默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。
基本属性：
id：Bean实例在Spring容器中的唯一标识
class：Bean的全限定名称
    （2）Bean标签范围配置。scope:指对象的作用范围，取值如下：
取值范围说明
singleton默认值，单例的
prototype多例的
requestWEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中
sessionWEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中
global sessionWEB 项目中，应用在 Portlet 环境，如果没有 Portlet 环境那么globalSession 相当于session

解释：
（1）当scope的取值为singleton时

Bean的实例化个数：1个
Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
Bean的生命周期：
对象创建：当应用加载，创建容器时，对象就被创建了
对象运行：只要容器在，对象一直活着
对象销毁：当应用卸载，销毁容器时，对象就被销毁了

（2）当scope的取值为prototype时

Bean的实例化个数：多个
Bean的实例化时机：当调用getBean()方法时实例化Bean
对象创建：当使用对象时，创建新的对象实例
对象运行：只要对象在使用中，就一直活着
对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

  • Bean生命周期配置
    init-method：指定类中的初始化方法名称
    destroy-method：指定类中销毁方法名称

  • Bean实例化三种方式

  • 1） 使用无参构造方法实例化
    它会根据默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败

<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl"/>

2） 工厂静态方法实例化
工厂的静态方法返回Bean实例

public class StaticFactoryBean {
  public static UserDao createUserDao(){  
  	return new UserDaoImpl();
 }
}

<bean id="userDao" class="com.demo.factory.StaticFactoryBean"
   factory-method="createUserDao" />

3） 工厂实例方法实例化
工厂的非静态方法返回Bean实例

public class DynamicFactoryBean { 
	public UserDao createUserDao(){    
		return new UserDaoImpl();
	}
}
<bean id="factoryBean" class="com.demo.factory.DynamicFactoryBean"/>
<bean id="userDao" factory-bean="factoryBean" factory-method="createUserDao"/>

控制反转 IOC
其并不是一项新技术，是一种思想理念。我们原先需要创建一个对象，然后通过new来创建。而IOC是相当于有人帮我们创建好了对象，需要使用的时候直接去拿就行。主要有两种实现方式:
DL（Dependency Lookup）：依赖查找(这种就是说容器帮我们创建好了对象，我们需要使用的时候自己再主动去容器中查找)

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/application-context.xml");
Object bean = applicationContext.getBean("object");

DI（Dependency Inject）：依赖注入。
依赖注入相比较依赖查找又是一种优化，也就是我们不需要自己去查找，只需要告诉容器当前需要注入的对象，容器就会自动将创建好的对象进行注入（赋值）。

  • Bean的依赖注入入门
    ①创建 UserService，UserService 内部在调用 UserDao的save() 方法
public class UserServiceImpl implements UserService {
@Override
public void save() {
    ApplicationContext applicationContext = new
        ClassPathXmlApplicationContext("applicationContext.xml");    
    UserDao userDao = (UserDao) applicationContext.getBean("userDao");
     userDao.save();
}
}

②将 UserServiceImpl 的创建权交给 Spring

<bean id="userService" class="com.demo.service.impl.UserServiceImpl"/>

③从 Spring 容器中获得 UserService 进行操作

ApplicationContext applicationContext = new
ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) applicationContext.getBean("userService");
userService.save();
  • Bean的依赖注入概念
    依赖注入（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。
    在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。
    IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。
    那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。
    简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取
  • Bean的依赖注入方式
    ①构造方法
    创建有参构造
public class UserServiceImpl implements UserService {
	private UserDao userDao;
	public UserServiceImpl(UserDao userDao){
		this.userDao = userDao;
	}
}

配置Spring容器调用有参构造时进行注入

<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.demo.service.impl.UserServiceImpl">   
<constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

②set方法
在UserServiceImpl中添加setUserDao方法

public class UserServiceImpl implements UserService {
  private UserDao userDao;
  public void setUserDao(UserDao userDao) {
    this.userDao = userDao; 
   }
  @Override  
  public void save() {   
 userDao.save();
}
}

配置Spring容器调用set方法进行注入

<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.demo.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"/>
</bean>

set方法:P命名空间注入
P命名空间注入本质也是set方法注入，但比起上述的set方法注入更加方便，主要体现在配置文件中，如下：
首先，需要引入P命名空间：

xmlns:p="http://www.springframework.org/schema/p"

其次，需要修改注入方式

<bean id="userService" class="com.demo.service.impl.UserServiceImpl" p:userDao-
ref="userDao"/>
  • Bean的依赖注入的数据类型
    上面的操作，都是注入的引用Bean，处了对象的引用可以注入，普通数据类型，集合等都可以在容器中进行注
    入。
    注入数据的三种数据类型
    普通数据类型
    引用数据类型
    集合数据类型
    其中引用数据类型，此处就不再赘述了，之前的操作都是对UserDao对象的引用进行注入的，下面将以set方法注入为例，演示普通数据类型和集合数据类型的注入。
    Bean的依赖注入的数据类型

（1）普通数据类型的注入

public class UserDaoImpl implements UserDao {
private String company;
  private int age;
  public void setCompany(String company) {
    this.company = company;
 }
  public void setAge(int age) {
    this.age = age;
 }
  public void save() {
    System.out.println(company+"==="+age);
    System.out.println("UserDao save method running...."); 
 }
}

<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl">
  <property name="company" value="公司"></property>
  <property name="age" value="15"></property>
</bean>

（2）集合数据类型（List）的注入

	public class UserDaoImpl implements UserDao {
	private List<String> strList;
	public void setStrList(List<String> strList) {
	this.strList = strList;
	}
	public void save() {
	    System.out.println(strList);
	    System.out.println("UserDao save method running....");
	}
	}

<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl">
  <property name="strList">
    <list>
      <value>aaa</value>
      <value>bbb</value>
      <value>ccc</value>
    </list>
  </property>
</bean>

（3）集合数据类型（List）的注入

public class UserDaoImpl implements UserDao {
private List<User> userList;
public void setUserList(List<User> userList) {
this.userList = userList; 
}
public void save() {
System.out.println(userList);
System.out.println("UserDao save method running....");
}
}

<bean id="u1" class="com.demo.domain.User"/>
<bean id="u2" class="com.demo.domain.User"/>
<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl">
  <property name="userList">
    <list>
      <bean class="com.demo.domain.User"/>
      <bean class="com.demo.domain.User"/>
      <ref bean="u1"/>
      <ref bean="u2"/>   
    </list>
  </property>
</bean>

（4）集合数据类型（ Map<String,User> ）的注入

public class UserDaoImpl implements UserDao {
  private Map<String,User> userMap;
  public void setUserMap(Map<String, User> userMap) {
  this.userMap = userMap;
 }  
public void save() {   
System.out.println(userMap);
System.out.println("UserDao save method running....");
}
}

<bean id="u1" class="com.demo.domain.User"/>
<bean id="u2" class="com.demo.domain.User"/>
<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl">
  <property name="userMap">
    <map>      
      <entry key="user1" value-ref="u1"/>
      <entry key="user2" value-ref="u2"/>
    </map>
  </property>
</bean>

（5）集合数据类型（Properties）的注入

public class UserDaoImpl implements UserDao {
  private Properties properties;
  public void setProperties(Properties properties) {
    this.properties = properties;
 }
public void save() {
System.out.println(properties);
System.out.println("UserDao save method running....");
}
}

<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl">
  <property name="properties">
    <props>
      <prop key="p1">aaa</prop>
      <prop key="p2">bbb</prop>
      <prop key="p3">ccc</prop>
    </props>
  </property>
</bean>

3.9 引入其他配置文件（分模块开发）
实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他配置文件中，而在Spring主配置文件通过import标签进行加载

<import resource="applicationContext-xxx.xml"/>
  1. spring相关API
    4.1 ApplicationContext的继承体系
    applicationContext：接口类型，代表应用上下文，可以通过其实例获得 Spring 容器中的 Bean 对象
    4.2 ApplicationContext的实现类
    1）ClassPathXmlApplicationContext
    它是从类的根路径下加载配置文件 推荐使用这种
    2）FileSystemXmlApplicationContext
    它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
    3）AnnotationConfigApplicationContext
    当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。
    4.3 getBean()方法使用
public Object getBean(String name) throws BeansException { 
assertBeanFactoryActive(); 
return getBeanFactory().getBean(name);
}
public <T> T getBean(Class<T> requiredType) throws BeansException {  
assertBeanFactoryActive();
return getBeanFactory().getBean(requiredType);
}

其中，当参数的数据类型是字符串时，表示根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。
当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错
getBean()方法使用

ApplicationContext applicationContext = new
      ClassPathXmlApplicationContext("applicationContext.xml");
 UserService userService1 = (UserService) applicationContext.getBean("userService");
 UserService userService2 = applicationContext.getBean(UserService.class);

参考学习网址：https://www.bilibili.com/video/BV1WZ4y1P7Bp

Soul酒吧
关注
专栏目录
Spring学习笔记
qq_43401687的博客
08-09 335
1.Spring 1.1简介 导入maven依赖 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.0.RELEASE</version> </dependency&gt
SSM-Spring01
最新发布
03-11
SSM-Spring01 本资源主要介绍了 SpringMVC 框架的基础知识，包括 SpringMVC 的概述、入门案例、工作流程解析等。 SpringMVC 概述 SpringMVC 是一种基于 Java 实现 MVC 模型的轻量级 Web 框架，它是 Spring 框架的...
Spring笔记
杨争的专栏
03-28 7757
  Spring笔记版权声明：如有转载请求，请注明出处：http://blog.csdn.net/yzhz  杨争         本文档适用于使用过Spring的开发者，该文章有助于他们重新梳理一下对Spring的认识。       这篇文章是本人在项目开发中使用Spring的总结，这里只是归纳了我们在开发中经常要用到的Spring的特性，Spring的其他特性或者使用起来比较复
SSM --Spring 第一天
qq_38288937的博客
09-21 657
1. spring概述 1.1 Spring是什么（理解） Spring是分层的 Java SE/EE应用 full-stack(全栈的，什么都会的，管家的 ) 轻量级开源框架，以 IoC：反转控制和 AOP：面向切面编程 为内核。 sring提供了展现层 SpringMVC和持久层 Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三...
【狂神说】Spring学习笔记（全）
热门推荐
li643937579的博客
11-27 4万+
Spring学习笔记1、Spring（2020-11-9）1.1 简介1.2 优点1.3 组成1.4 拓展2、IOC理论推导IOC本质3、HelloSpring 1、Spring（2020-11-9） 1.1 简介 SSH：Struct2 + Spring + Hibernate! SSM：SpringMVC + Spring + Mybatis! 官网：https://spring.io/projects/spring-framework#overview 官方下载地址：https://repo.sp
SSM-Spring02
03-11
SpringMVC 入门案例和 RESTful 风格 SpringMVC 是一种基于 Java 实现 MVC 模型的轻量级 Web 框架，它是 ...通过学习 SpringMVC 的入门案例和 RESTful 风格，可以快速掌握 SpringMVC 的使用和设计网络应用程序的架构。
SSM_Redis_Template：基于Maven的模板，使用Spring + Spring MVC + mybatis + spring-data-redis框架。 它可以用于快速构建新的Java Web Appliaction。
02-04
基于maven的Java web项目框架模板，使用spring + spring_mvc + mybatis + spring-data-redis等框架各种配置文件都已写好的并实现了一个简单的登陆注册功能可用于在IDEA上快速构建网络项目或入门学习 更多spring_mvc...
ssm-parent.rar
08-10
SSM-Parent是一个基于Maven构建的入门级聚合项目，旨在帮助初学者理解Maven中的三个核心概念：依赖（Dependencies）、继承（Inheritance）和聚合（Aggregation）。在这个项目中，我们将深入探讨这些概念以及它们在...
SSMM-Demo：实践出真知，相对于SSM-Demo项目，本项目是一个基于SSMM（SpringMVC + Spring + Mybatis + Redis + Maven）的练手Demo
02-03
本项目是一个基于Spring MVC + Spring + Mybatis + Redis + Maven的入门级（拥有完整的登录/注册逻辑）。Demo，是在SSM-Demo项目的基础上修改，调整而来，主要涉及以下几项技术及知识点： 使用SpringMVC作MVC控制器...
SPRING 笔记SPRING 笔记
03-05
SPRING 笔记SPRING 笔记SPRING 笔记
Spring学习笔记（一）
YinXin的博客
10-27 150
什么是控制反转？ 控制：一般程序会主动创建对象，并控制对象。 反转：正转是我们需要对创建的对象主动去设置依赖的资源和对象。反转，我们不用主动去设置。 IOC容器帮我们去控制我们所需要的对象，并且对象所以来的资源，IOC去创建并帮我们设置好，所有，当我们从IOC容器拿到对象后，这个对象可以直接使用，提高了程序的功能复用，并进行了解耦。 什么是依赖注入？ 依赖了什么：应用程序需要依赖IOC容器来获得资...
Spring学习笔记(1)
特立独行
12-09 397
l       Spring提供的IoC(控制翻转)容器依赖注入:IoC容器有三种依赖注入方式，（1）构造方法注入：在构造方法中注入所需要的以来组件；（2）设置属性注入：Spring的IoC容器推荐的方式，通过简单的setter方法注入；（3）接口注入：在接口中定义需要注入的信息。       IoC容器使用工厂模式创建需要的JavaBean,如图一： 图一XML配置文件示
Spring学习笔记（全）
Ur_Eyes_的博客
08-10 468
Spring的概述 Spring是什么？ Spring是分层的JavaSE/JavaEE应用full-stack的轻量级开源框架，以IOC（Inverse Of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）为核心，提供了表现层SpringMVC和持久层Spring JDBC以及业务层事务管理等众多企业级应用技术的支持，还可以整合众多第三方框架。 Spring的优势 方便解耦，简化开发 AOP 编程的支持 声明式事务的支持 方便程序的测试 方
spring 学习笔记
流沙-岁月
07-13 348
一. AOP       OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是
SSM框架搭建教程：新手入门与Maven配置
"本文档详细介绍了如何使用SSM框架进行项目搭建，针对初学者设计了简单...整个过程旨在帮助读者理解SSM框架的结构和工作原理，包括前后端分离、依赖注入、持久层封装等关键概念，适合那些希望快速入门SSM开发的人员。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值