SpringFramework初使用

最新推荐文章于 2024-06-24 03:58:41 发布
最新推荐文章于 2024-06-24 03:58:41 发布
阅读量211 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nazabanma/article/details/104503345
版权
这篇博客介绍了如何将Java Maven项目转化为Web Maven项目，包括修改pom.xml配置，创建webapp目录和web.xml。还讲解了如何在不部署Tomcat的情况下，使用Maven插件运行项目。此外，文章详细阐述了Spring Framework的使用，包括注入依赖、创建Spring配置文件，以及Spring容器的概念和Bean的生命周期。最后，讨论了XML命名空间在配置文件中的应用。
摘要由CSDN通过智能技术生成

将普通javaMaven项目变成webMaven项目

1、在pom.xml文件中添加，将项目打包成war（java项目打包为jar）

<packaging>war</packaging>

2、接着在main文件夹下添加webapp文件夹，
再在webapp文件夹下添加WEB-INF文件夹，
再在WEB-INF中添加web.xml
webMaven项目的结构

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                               http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         version="2.5">
        <welcome-file-list>
            <welcome-file>index.html</welcome-file>
        </welcome-file-list>
</web-app>

在不部署tomcat的情况下，使用插件运行项目

有关build表标签的简述：

  1. 一种被称为Project Build（全局配置），即是的直接子元素。
  2. 另一种被称为Profile Build（配置），即是的直接子元素。

有关build标签详情请看https://www.cnblogs.com/yinziqiang0909/p/11724266.html

在此我只用到了plugins配置

  • groupId：是项目组织唯一的标识符，实际对应JAVA的包的结构，是main目录里java的目录结构
  • artifactId：就是项目的唯一的标识符，实际对应项目的名称，就是项目根目录的名称
  • version：版本号
  • configuration：该插件所需要的特殊配置，在父子项目之间可以覆盖或合并

在pom.xml的project标签下写入以下代码

<!-- 插件 -->
    <build>
        <plugins>
            <!-- define the project compile level -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

            <!-- 添加tomcat插件 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <path>/</path>
                    <port>8081</port>
                </configuration>
            </plugin>
        </plugins>
    </build>

1、接着打开Maven窗口
打开Maven窗口
2、运行项目（第一次运行，程序会自行下载，接着再运行一次即可）
运行项目
3、运行结果：
运行结果图

使用StrpingFramework

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>

注入SpringFramework
2、点击resources，右键new—>XML Configuration File—>Spring Config
在这里插入图片描述
3、我们先创建一个Person类，在构造方法中各打印一句话

public class Person {
    private int id;
    private String name;
    private int age;
    private boolean sex;

    public Person(){
		System.out.println("无参构造");
    }

    public Person(int id, String name, int age, boolean sex) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
        System.out.println("有参构造");
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + (sex ?"boy" : "girl") +
                '}';
    }

简单的进行配置bean对象

<?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="person1" class="com.qfedu.bean.Person">
        <property name="id" value="1"/>
        <property name="name" value="张爱国"/>
        <property name="age" value="18"/>
        <property name="sex" value="true"/>
    </bean>
</beans>

4、再创建一个PersonDemo测试类

简单介绍一下Spring容器——Spring容器是生成Bean实例的工厂，并管理容器中的Bean

有关Spring容器详情请看https://www.jianshu.com/p/2854d8984dfc

BeanFactory和ApplicationContext是Spring的两大核心接口，而其中ApplicationContext是BeanFactory的子接口

  • ApplicationContext（应用上下文）常用实现类
  1. FileSystemXmlApplicationContext——从文件系统下的一个或多个xml配置文件中加载上下文定义，也就是说系统盘符中加载xml配置文件。
  2. ClassPathXmlApplicationContext——从类路径下的一个或多个xml配置文件中加载上下文定义，适用于xml配置的方式

测试代码：

这里我们使用ClassPathXmlApplicationContext类

public class PersonDemo {
    @Test
    public void testPerson(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        Person p1 = (Person) ac.getBean("person1");
        System.out.println(p1);
    }
}

运行结果：
调用了无参构造
从结果可以看出调用了无参构造，并通过get、set方法赋值，而不是调用有参构造

我们再看看使用有参构造的方法

在beans.xml中添加一下代码，我们使用了constructor-arg标签

<bean id="person2" class="com.qfedu.bean.Person">
        <constructor-arg name="id" value="1" />
        <constructor-arg name="name" value="张爱国" />
        <constructor-arg name="age" value="18" />
        <constructor-arg name="sex" value="true" />
    </bean>

测试代码：

    @Test
    public void testPerson(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        Person p1 = (Person) ac.getBean("person1");
        System.out.println(p1);

        Person p2 = (Person) ac.getBean("person2");
        System.out.println(p2);
    }

运行结果：
调用了有参构造
我们再来看看下面的代码：

    @Test
    public void testPerson(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        Person p1 = (Person) ac.getBean("person1");
        Person p2 = (Person) ac.getBean("person1");
        System.out.println(p1 == p2);

        Person p3 = (Person) ac.getBean("person2");
        Person p4 = (Person) ac.getBean("person2");
        System.out.println(p3 == p4);

        System.out.println(p1 == p3);
    }

运行结果：
默认是单例模式
我们可以看出，p1 和 p2 、p3 和 p4 是同一个对象，这说明bean对象默认是单例模式。
我们可以通过添加scope属性为prototype,将bean对象设置为多实例对象

<bean id="person1" class="com.qfedu.bean.Person" scope="prototype">
        <property name="id" value="1"/>
        <property name="name" value="张爱国"/>
        <property name="age" value="18"/>
        <property name="sex" value="true"/>
    </bean>

我们甚至可以混合使用

在Person类中添加一个构造方法

public Person(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

在beans.xml中添加

<bean id="person3" class="com.qfedu.bean.Person">
        <constructor-arg name="id" value="1" />
        <constructor-arg name="name" value="张爱国" />
        <constructor-arg name="age" value="18" />
        <property name="sex" value="false"/>
    </bean>

测试代码：

@Test
    public void testPerson(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        Person p3 = (Person) ac.getBean("person3");
        System.out.println(p3);
    }

运行结果：
混合使用
如果对象的属性中包含对象呢？

创建一个Address类

public class Address {
    private int id;
    private String province;
    private String city;

    public Address(){
        
    }
    
    public Address(int id, String province, String city) {
        this.id = id;
        this.province = province;
        this.city = city;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address{" +
                "id=" + id +
                ", province='" + province + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

在Person类中添加Address属性 和 一个构造方法 以及set、get 方法

private Address address;

public Person(int id, String name, int age, boolean sex, Address address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.address = address;
    }

在beans.xml中的代码,使用ref调用address1的引用

<bean id="address1" class="com.qfedu.bean.Address">
        <property name="id" value="1"/>
        <property name="province" value="湖北"/>
        <property name="city" value="武汉"/>
    </bean>
    
    <bean id="person4" class="com.qfedu.bean.Person">
        <property name="id" value="2"/>
        <property name="name" value="张爱岗"/>
        <property name="age" value="20"/>
        <property name="sex" value="true"/>
        <property name="address" ref="address1"/>
    </bean>

运行结果：
对象的引用

命名空间的使用

命名空间的作用：XML 命名空间提供避免元素命名冲突的方法。

  1. 使用前缀来避免命名冲突
    在头文件中添加xmlns:p="http://www.springframework.org/schema/p"(p是代表namespace,xmlns后的p可以改名)
<bean id="address2" class="com.qfedu.bean.Address" p:id="2" p:province="湖南" p:city="长沙"/>
    <bean id="person5" class="com.qfedu.bean.Person" p:id="3" p:name="李四" p:age="18" p:sex="false" p:address-ref="address2"/>
?1?
关注
spring batch初使用
LitRad
12-08 386
Spring Batch 背景   项目需要将一部分老数据进行迁移,谷歌百度一番,自己决定就用spring batch了.资料是真滴挺少的,反正就是很多坑,一步步踩完了.记录下,顺便也给网友们提供下帮助.   主要应用大概就是我需要读一部分数据,然后对他进行一部分操作,然后写入某个地方.对应于流程于reader->processor->writer   引用下wiki上的介绍   S...
java-spring-framework-main
02-18
弹簧框架
Spring 框架基本使用（详细）
最新发布
2401_85111725的博客
06-24 719
AOP（Aspect Oriented Programming）:面向切面编程，即通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术，AOP是Spring框架中一个重要的技术，Spring 中的 AOP，就是通过配置的方式，实现动态代理的过程，它是函数式编程的一种衍生范型，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间耦合度降低，提高程序的可重用性和开发效率。ref：用于指定其他的bean类型数据，它指的是在Spring的IOC核心容器出现过的bean对象。
SSM框架之Spring Framework 简单使用
mexiang2438的博客
11-21 319
要先使用，先来了解什么是IOC，AOP,DI? 通俗的来讲:IOC，即控制反转，是一种思想。即由主动得到控制对象，变成被动获得，由IOC来控制，过程反转了，因此得名。 官方文档：这是一个过程，其中对象仅通过构造函数参数、工厂方法的参数或对象实例在构造或从工厂方法返回后在对象实例上设置的属性来定义它们的依赖项（即，它们使用的其他对象） .然后容器在创建 bean 时注入这些依赖项。这个过程基本上是 bean 本身通过使用类的直接构造或诸如服务定位器模式之类的机制来控制其依赖项的实例化或位置的逆过程（因.
SpringFramework实战指南（四）
晴天学长
01-19 1155
依赖注入（DI）包含引用类型和基本数据类型，同时注入的方式也有多种！主流的注入方式为setter方法注入和构造函数注入，两种注入语法都需要掌握！需要特别注意：引用其他bean，使用ref属性。直接注入基本类型值，使用value属性。
Spring框架使用流程
SSimeng的博客
09-03 704
Spring框架使用流程一 、过程简单梳理二、 Spirng的基本配置及用法1.Maven项目中Spring框架的依赖引入2.配置Spring配置文件的三种方式（1）纯xml文件配置（applicationContext.xml）（2）利用注解配置（还需要xml配置文件，但相较于第一种，已经简单了)（3）使用配置类替代xml文件3.Spring如何进行单元测试三、 Spirng的IOC和DI 一 、过程简单梳理 tomcatl启动 -》dispatcherServlet(会自动（根据springmvc-s
spring framework 简介
09-08
2. **全面与模块化**：Spring Framework 采用了分层架构设计，这让开发者可以根据自己的需求选择使用框架中的某些特定部分，而无需全部依赖整个框架。这种灵活性意味着无论是简单的JDBC访问还是复杂的业务对象管理，...
Java Spring Framework 平台参考手册（916页完整版）
03-17
- **开始使用 Spring** - 介绍了如何搭建 Spring 开发环境、配置项目结构等基础知识。 - **Spring Framework 介绍** - 详细阐述了 Spring Framework 的核心概念、架构设计和主要组件。 - **依赖注入与控制反转** ...
springframework-1.0.zip早期版本雏形
04-26
在这个"springframework-1.0.zip"早期版本中，我们可以看到Spring发展的初期形态，这对于理解其设计理念和演进历程具有重要价值。 在Spring 1.0时代，核心的IoC容器（Bean Factory）是整个框架的基础，它负责管理...
Spring Boot报错 org.springframework.jdbc.BadSqlGrammarException
Ajekseg的博客
08-02 891
有时候在命名的时候一定的注意，不能和SQL中的关键字冲突，java中也会是，我真的是被自己的偷懒上了一课哇，如果大家有这个问题，可以去看看是自己SQL有问题，还是字段名和关键字冲突了，都不是的话认真分析错误日志。先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。httpshttpshttpshttpshttps。...
spring framework入门(7)：spring framework面向切面编程示例（xml配置）
火焰
08-06 441
参照：https://www.cnblogs.com/kuotian/p/8863257.html 示例代码：http://download.csdn.net/detail/u010476739/9922458 工具：spring framework 4.2.4、maven 使用xml配置实现spring-aop 1.pom依赖 <project xmlns="http:/...
使用main方法启动spring程序
二师兄想吃肉的博客
09-23 3859
在 spring 框架中，由于对象都交给了 IoC 容器进行管理，那么直接在 main 方法中创建 service 层对象，就会出现空指针异常（NPE）。正确的方式是从 IoC 的容器中取出对象，再使用对象中的方法或者属性就可以了。
SpringFrameWork(5)
JustinNeil的博客
07-07 313
AOP AOP概念 AOP就是面向切面编程，指的是在业务代码执行的过程中动态的嵌入其他代码。 就是将交叉业务逻辑封装成切面，利用AOP的功能将切面织入到主业务逻辑中。所谓交叉业务逻辑是指，通用的、与主业务逻辑无关的代码，如安全检查、事务、日志等。若不使用AOP，则会出现代码纠缠，即交叉业务逻辑与主业务逻辑混合在一起。这样，会使主业务逻辑变的混杂不清。 常见的使用场景： 权限检查 日志记录 事务 数...
SpringFramework学习之入门篇（一）
会写诗的程序猿的博客
10-17 7854
SpringFramework学习之入门篇一：准备工作1:安装JDK2:安装 Apache Commons Logging API3:下载IDEA开发工具4:安装 Spring 框架库5:单独建资源库（仅参考）二：SpringFramework基础1: Spring概述1.1:概述1.2：Spring框架的优点1.3:依赖注入（DI）1.4:面向方面的程序设计（AOP）2: Spring体系结构2...
为什么我们需要Spring Framework ?
「有且仅有」
04-07 2656
一、为什么我们需要Spring Framework ? 1. 从J2EE说起 1998 年Sun 公司发表JDK 1.2 时，分别发表了标准版-J2SE、企业版-J2EE、微型版-J2ME。J2EE 诞生。 2005 年Java One 大会上Sun 公布了JDK 1.6，J2XX 全部改名为JavaXX，J2EE 改名为JavaEE。 2018 年3月，Eclipse 基金会将Java...
spring ioc 容器 基本使用
qq_39367438的博客
11-10 178
引入spring核心框架 最简单的方式，通过maven将依赖引入 &amp;amp;lt;project xmlns=&amp;quot;http://maven.apache.org/POM/4.0.0&amp;quot; xmlns:xsi=&amp;quot;http://www.w3.org/2001/XMLSchema-instance&amp;quot; xsi:schemaLocation=&amp;quot;http://mav
Spring架构详解之Context组件详解
u010662668的博客
03-16 1318
Context在Spring的org.springframework.context包下，前面已经讲解了Context组件在Spring中的作用，他实际上就是给Spring提供一个运行时的环境，用以保存各个对象的状态。下面看一下这个 环境是如何构建的。 ApplicationContext是Context的顶级父类，他除了能标识一个应用环境的基本信息外，他还继承了五个接口，这五个接口主要是扩
Spring Framework
jamenu的博客
09-03 230
Spring Framework的IOC的使用 一.搭建spring framework 环境 创建普通的Java Project 引入User lib库 在User库中放入spring的依赖jar包（spring5） 二.配置appliactionContext.xml 在src下创建applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值