Spring学习

已于 2023-02-11 10:09:46 修改
阅读量290 收藏
点赞数 1
文章标签： spring 学习 java Powered by 金山文档
于 2023-02-10 19:56:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/trappedhua/article/details/128969201
版权

快速上手：

  1. 创建Student类

package com.nhooo;
public class Student {
private String name;
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public void displayInfo(){
    System.out.println("Hello: "+name);
}
}

  1. 创建applicationContext.xml 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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id="studentbean" class="com.nhooo.Student">
<property name="name" value="Vimal Jaiswal"></property>
</bean>
</beans>

bean 元素用于为给定类定义bean。 bean的 property 子元素指定名为name的Student类的属性。属性元素中指定的值将由IOC容器在Student类对象中设置。

  1. 获取Student对象并打印 

package com.nhooo;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
public class Test {
public static void main(String[] args) {
    Resource resource=new ClassPathResource("applicationContext.xml");
    BeanFactory factory=new XmlBeanFactory(resource);
    
    Student student=(Student)factory.getBean("studentbean");
    student.displayInfo();
}
}

Spring原理

Spring 是轻量级的开源javaEE框架 简化企业应用开发复杂性 本质上是工厂模式：在service和dao层之间加上BeanFactory类 用来创建dao对象 供services使用

IOC容器

IoC容器负责实例化，配置和组装对象。 IoC容器从XML文件获取信息并相应地工作。 IoC容器执行的主要任务是:

实例化应用程序类配置对象组装对象之间的依赖关系

IOC容器有两个类型

  1. BeanFactory --org.springframework.beans.factory

Resource resource=new ClassPathResource("applicationContext.xml");
BeanFactory factory=new XmlBeanFactory(resource);

  1. ApplicationContext --org.springframework.context

ApplicationContext context = 
    new ClassPathXmlApplicationContext("applicationContext.xml");

ApplicationContext 接口充当IoC容器。 ApplicationContext接口建立在BeanFactory接口的顶部。它比BeanFactory增加了一些额外的功能，例如与Spring的AOP的简单集成，消息资源处理(用于I18N)，事件传播，Web应用程序的特定于应用程序层的上下文(例如WebApplicationContext)。因此，使用ApplicationContext比使用BeanFactory更好

IOC管理bean的两种方式

Spring依赖注入（构造函数或setter）

依赖注入是一种设计模式，它消除了程式。在这种情况下，我们提供来自外部源(例如XML文件)的信息。它使我们的代码松散耦合，并且更易于测试

通常设计对象时 提供外部赋值功能 代码如下：

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

在这种情况下，Address类的实例由外部源(例如XML文件)通过构造函数或setter方法提供。

通过构造器注入的方式

int注入

<bean id="e" class="com.nhooo.Employee">
<constructor-arg value="10" type="int"></constructor-arg>
</bean>

String注入

<bean id="e" class="com.nhooo.Employee">
<constructor-arg value="10"></constructor-arg>
</bean>

对象注入 ref

<bean id="a1" class="com.nhooo.Address">
<constructor-arg value="ghaziabad"></constructor-arg>
<constructor-arg value="UP"></constructor-arg>
<constructor-arg value="India"></constructor-arg>
</bean>

<!--注入a1对象到e中-->
<bean id="e" class="com.nhooo.Employee">
<constructor-arg value="12" type="int"></constructor-arg>
<constructor-arg value="Sonoo"></constructor-arg>
<constructor-arg>
<ref bean="a1"/>
</constructor-arg>
</bean>

list注入

<constructor-arg>
<list>
<value>Java is a programming language</value>
<value>Java is a Platform</value>
<value>Java is an Island of Indonasia</value>
</list>
</constructor-arg>

<!--注入的元素中含有对象的注入-->
<constructor-arg>
<list>
<ref bean="ans1"/>
<ref bean="ans2"/>
</list>
</constructor-arg>

Map注入

<constructor-arg>
<map>
<entry key="Java is a Programming Language"  value="Ajay Kumar"></entry>
<entry key="Java is a Platform" value="John Smith"></entry>
<entry key="Java is an Island" value="Raj Kumar"></entry>
</map>
</constructor-arg>

<!--注入的元素中含有对象的注入-->
<constructor-arg>
<map>
<entry key-ref="answer1" value-ref="user1"></entry>
<entry key-ref="answer2" value-ref="user2"></entry>
</map>
</constructor-arg>

通过SETTER方法注入的方式

int、String注入

<bean id="obj" class="com.nhooo.Employee">
<property name="id">
<value>20</value>
</property>
<property name="name">
<value>Arun</value>
</property>
<property name="city">
<value>ghaziabad</value>
</property>
</bean>

对象注入

其中ref属性时 对另一个bean的应用

<property name="address" ref="address1"></property>

List注入

<property name="answers">
<list>
<value>Java is a programming language</value>
<value>Java is a platform</value>
<value>Java is an Island</value>
</list>

Spring自动装配

byName自动装配模式

在byName自动装配模式下，bean id和引用名称必须相同。b = org.sssit.B 

<bean id="b" class="org.sssit.B"></bean>
<bean id="a" class="org.sssit.A" autowire="byName"></bean>

byType自动装配模式

bean ID和引用名称可能不同。但是只能有一个类型的bean。

<bean id="b1" class="org.sssit.B"></bean>
<bean id="a" class="org.sssit.A" autowire="byType"></bean>

在这种情况下，它可以正常工作，因为您创建了B类型的实例。没关系，您可以使用与引用名称不同的Bean名称。

但是，如果您具有一种类型的多个Bean，它将不起作用并抛出异常。

构造函数自动装配模式

如果一个类中的3个构造函数，零参数，一个参数和两个参数，然后通过调用两个参数构造函数执行注入。

<bean id="b" class="org.sssit.B"></bean>
<bean id="a" class="org.sssit.A" autowire="constructor"></bean>

没有自动装配模式

<bean id="b" class="org.sssit.B"></bean>
<bean id="a" class="org.sssit.A" autowire="no"></bean>

在没有自动装配模式的情况下，spring容器不会通过自动装配注入依赖项。

Spring jdbcTemplete

旧JDBC API的问题：

操作繁琐 ：创建链接 SQL语句 关闭结果集。

我们需要在数据库逻辑上执行异常处理代码。我们需要处理交易。

将所有这些代码从一个数据库逻辑重复到另一个数据库逻辑是一项耗时的工作。

而Spring JdbcTemplate消除了上述JDBC API的所有问题。它提供了直接编写查询的方法，从而节省了大量的工作和时间。

JdbcTemplate类 负责创建和释放资源 例如创建和关闭连接对象等 如果忘记关闭连接也不会导致任何问题

dbcTemplate类提供的方法：

方法名

说明

public int update(String query)

用于插入，更新和删除记录。

public int update(String query，Object ... args)

用于通过使用给定参数的PreparedStatement插入，更新和删除记录。

public void execute(String query)

用于执行DDL查询。

public T execute(String sql, PreparedStatementCallback action)

通过使用PreparedStatement回调执行查询。

public T query(String sql, ResultSetExtractor rse)

用于使用ResultSetExtractor获取记录。

public List query(String sql, RowMapper rse)

用于使用RowMapper获取记录。

代码示例

package com.nhooo;
import org.springframework.jdbc.core.JdbcTemplate;
public class EmployeeDao {
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
      this.jdbcTemplate = jdbcTemplate;
    }
    public int saveEmployee(Employee e){
      String query="insert into employee values(  '"+e.getId()+"','"+e.getName()+"','"+e.getSalary()+"')";
      return jdbcTemplate.update(query);
    }
    public int updateEmployee(Employee e){
      String query="update employee set 
      name='"+e.getName()+"',salary='"+e.getSalary()+"' where id='"+e.getId()+"' ";
      return jdbcTemplate.update(query);
    }
    public int deleteEmployee(Employee e){
      String query="delete from employee where id='"+e.getId()+"' ";
      return jdbcTemplate.update(query);
    }
}
<?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:p="http://www.springframework.org/schema/p"
  xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!--DriverManagerDataSource 用于包含有关数据库的信息，例如驱动程序类名称，连接URL，用户名和密码。-->
<bean id="ds" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
<property name="url" value="jdbc:oracle:thin:@localhost:1521:xe" />
<property name="username" value="system" />
<property name="password" value="oracle" />
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="ds"></property>
</bean>
<bean id="edao" class="com.nhooo.EmployeeDao">
<property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>
</beans>

获取bean

  ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");

  EmployeeDao dao=(EmployeeDao)ctx.getBean("edao");
  int status=dao.saveEmployee(new Employee(102,"Amit",35000));
  System.out.println(status);
    
  /*int status=dao.updateEmployee(new Employee(102,"Sonoo",15000));
  System.out.println(status);
  */
    
  /*Employee e=new Employee();
  e.setId(102);
  int status=dao.deleteEmployee(e);
  System.out.println(status);*/

Spring ORM框架

什么是ORM

即Object Relational Mapping，它是对象关系模型的简称。它的作用是在关系型数据库和对象之间作一个映射。使程序能够通过操纵描述对象方式来操纵数据库。

ORM解决的主要问题是对象关系的映射，一般情况下，一个持久化类和一个表对应，类的每个实例对应表中的一条记录，类的每个属性对应表的每个字段。 ## ORM技术特点：

提高了开发效率。由于ORM可以自动对Entity对象与数据库中的Table进行字段与属性的映射，所以我们实际可能已经不需要一个专用的、庞大的数据访问层。

ORM提供了对数据库的映射，不用sql直接编码，能够像操作对象一样从数据库获取数据。

Spring如何集成ORM

市面上主流的ORM框架有 Hibernate和mybatis

Spring MVC

它遵循Model-View-Controller设计模式。它实现了核心Spring框架的所有基本功能，例如控制反转，依赖注入。

SpringMVC流程和原理

所有的requestid都会被DispatcherServlet拦截

拦截后DispatcherServlet会从web.xml文件中获取处理映射的条目 并将request转发到控制器

控制器返回modelandview对象

SpringMVC框架示例

  1. 在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.nhooo</groupId>
  <artifactId>SpringMVC</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>SpringMVC Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.1.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>  
    <groupId>javax.servlet</groupId>  
    <artifactId>servlet-api</artifactId>  
    <version>3.0-alpha-1</version>  
</dependency>
  </dependencies>
  <build>
    <finalName>SpringMVC</finalName>
  </build>
</project>

  1. 创建controller控制类

要创建控制器类，我们使用两个注释@Controller和@RequestMapping。

@Controller注释将该类标记为Controller。

@Requestmapping批注用于映射具有指定URL名称的类。

package com.nhooo;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class HelloController {
@RequestMapping("/")
  public String display()
  {
    return "index";
  } 
}

  1. 在web.xml文件中提供控制器的条目

在此web.xml文件中，我们指定Servlet类DispatcherServlet充当Spring Web MVC中的前端控制器。 html文件的所有传入请求都将转发到DispatcherServlet。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>SpringMVC</display-name>
   <servlet>  
    <servlet-name>spring</servlet-name>  
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
    <load-on-startup>1</load-on-startup>    
</servlet>  
<servlet-mapping>  
    <servlet-name>spring</servlet-name>  
    <url-pattern>/</url-pattern>  
</servlet-mapping>  
</web-app>

  1. 在xml文件中定义bean。

这是重要的配置文件，需要在其中指定View组件。

context: component-scan元素定义了DispatcherServlet的基本包。将搜索控制器类。

此xml文件应位于WEB-INF目录内。

<?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:context="http://www.springframework.org/schema/context"
  xmlns:mvc="http://www.springframework.org/schema/mvc"
  xsi:schemaLocation="
    http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/context
      http://www.springframework.org/schema/context/spring-context.xsd
      http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
  <!-- Provide support for component scanning -->
  <context:component-scan base-package="com.nhooo" />
  <!--Provide support for conversion, formatting and validation -->
  <mvc:annotation-driven/>
</beans>

  1. 在JSP页面中显示消息

index.jsp

<html>
<body>
<p>Welcome to Spring MVC Tutorial</p>
</body>
</html>

词它不达意
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Spring框架学习：ApplicationContext.xml的配置和运用
qq_53641185的博客
08-08 2159
ApplicationContext.xml文件。如下是Test1的测试类。如下是Test2的测试类。
Propagation Propagation的七种事务属性 七种事务属性 NOT_SUPPORTED REQUIRED
qq_44043843的博客
10-09 6625
Propagation类的七种事务属性解释（REQUIRED，SUPPORTS，MANDATORY，REQUIRES_NEW，NOT_SUPPORTED，NESTED，NEVER） Spring中七种Propagation类的事务属性详解： REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 required SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。 supports MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。.
配置applicationContext.xml文件
最新发布
技术研究中心
06-29 1153
是Spring应用程序的上下文配置文件，用于定义Spring容器中bean的创建、初始化、装配和管理。在这个文件中，我们可以配置各种bean及其依赖关系，甚至可以定义切面、事务管理、数据源等。每个bean元素都有一个唯一的id属性，用于标识bean实例，还有一个class属性，用于指定bean的实现类。是Spring应用程序的核心配置文件，负责管理和配置应用程序中的各种bean。在这个示例中，我们启用了注解驱动的事务管理，这样我们可以在代码中使用。的方法，Spring会自动调用这个方法，将。
Spring的applicationContext.xml配置文件
qq_68334807的博客
01-06 1005
applicationContext.xml配置文件，包括自动扫描等内容，书写ssm框架是推荐与web.xml，SpringMVC-servlet.xml一起使用。--实体类 起别名-->--加载映射文件-->--注入数据源-->
eclipse里配置spring的applicationContext.xml约束的引入
zaomengzhe666777的博客
03-17 1989
spring xml引入约束的自认为正规方法,总觉得从网上拷贝粘贴约束不太正规.相对繁琐一些,但是万一上不了网呢.
applicationcontext.xml的作用
weixin_44943389的博客
06-03 1333
它用于声明和配置 Bean、依赖注入、AOP 配置、事务管理等，以帮助管理和组织应用程序中的各种组件。在 Spring 中，应用程序上下文是一个重要的容器，用于管理和组织应用程序中的各种组件，包括 Bean 的定义、依赖注入、AOP 配置、事务管理等。元素用于配置应用程序中的切面（Aspect），包括切入点（Pointcut）、通知（Advice）和切面的关联等。文件还可以包含其他的配置元素，例如资源引用、环境配置、国际化配置等，以满足应用程序的需求。元素，可以声明和配置应用程序中的各种 Bean 对象。
spring学习.zip
11-01
本资源集合围绕"spring学习.zip"，提供了多本深入讲解Spring及其相关技术的电子书籍，旨在帮助读者深入理解和掌握Spring生态。 1. **《深入实践Spring Boot.陈韶健.pdf》**：这本书详细介绍了Spring Boot，它是...
spring 学习
08-04
spring学习，通过搭建基本的工程，从中学习spring的原理
spring学习
03-07
spring系统学习，解读spring，源码解读 spring系统学习，解读spring，源码解读 spring系统学习，解读spring，源码解读
spring学习资源
10-12
学习spring资源书籍，第三版讲解的很全面，包括springmvc的整合
applicationcontext.xml配置文件
ou980945409的博客
05-17 243
/bean></bean></bean></beans>
applicationContext.xml配置简介
qq_42946963的博客
07-07 1万+
spring的配置文件applicationContext.xml中的一些配置的作用。 1. 配置组件扫描器，使用注解方式开发 <context:component-scan base-package="com.item.ikell"/> 表示启动spring的组件扫描功能（从spring2.5版本开始）。即Spring容器初始化时，扫描base-package包或者子包下面的Java文件，如果扫描到有@controller、@Service、@Repository、@Component等
如何找到Spring的applicationContext.xml配置文件
热门推荐
TianXinCoord的博客
09-12 2万+
目录 一、文章前言 二、applicationContext.xml查找 一、文章前言 Spring需要加载配置文件applicationContext.xml，那么自带的jar包又没有，该如何查找；在网上找又怕找的不对，那么其实很简单，当我们在jar包找不到我们需要的文件的时候首先应该想到去官网查找 二、applicationContext.xml查找 1.我们可以去Spring的官...
ApplicationContext详解以及多个ApplicationContext.xml的相互引用
程序员蒋老湿的博客
06-15 3273
如果说BeanFactory是spring的心脏，那么Application就是完整的身躯。ApplicationContext就是由BeanFactory派生出来的。一、ApplicationContext类ApplicationContext的主要实现类是ClassPathXmlApplicationContext和FileSystemXmlApplicationContext,前者默认从类...
配置applicationContext.xml详解
蓝魔
09-09 824
想必用过Spring的程序员们都有这样的感觉，Spring把逻辑层封装的太完美了（个人感觉View层封装的不是很好）。以至于有的初学者都不知道Spring配置文件的意思，就拿来用了。所以今天我给大家详细解释一下Spring的applicationContext.xml文件。Ok，还是通过代码加注释的方式为大家演示：  以下是详解Spring
IDEA 创建applicationContext.xml
星河的专栏
09-28 1万+
右键 new -》XML Configuration File-》spring config 若没有这个选项，就是spring相关的包没有导入，pom没有依赖 spring相关包https://mvnrepository.com/查找 <dependency> <groupId>org.springframework</groupId&g...
如何在springmvc中快速的新建applicationContext.xml
ranchill的博客
07-18 1117
快速新建xml配置文件步骤1、方法：2、关于配置文件： 1、方法： File ---->new ---- other，然后如图 如上图输入spring，选择Spring Bean Definition即可 2、关于配置文件： a.如果将配置文件放在WEB-INF文件目录下，此时默认的配置文件存放路径。 b.如果将配置文件放在根目录下，则需要在web.xml文件中配置路径。 ...
ApplicationContext.xml的两种配置方式
qq_38872310的博客
12-27 3034
ContextLoaderListener的作用就是启动Web容器时，自动装配ApplicationContext的配置信息。因为它实现了ServletContextListener这个接口，在web.xml配置这个监听器，启动容器时，就会默认执行它实现的方法。至于ApplicationContext.xml这个配置文件部署在哪，如何配置多个xml文件，书上都没怎么详细说明。现在的方法就是查看它的...
Spring学习指南：13章深度解析与模块切换
Spring学习笔记是一份详细指南，针对Spring框架的初学者和进阶者设计，作者newchq在JavaEye网站上分享了其学习过程中整理的13个关键章节。Spring框架的发布极大地简化了企业级应用的开发，特别是依赖注入和面向切面...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值