Spring入门与常用配置

最新推荐文章于 2024-09-21 10:38:43 发布
最新推荐文章于 2024-09-21 10:38:43 发布
阅读量555 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/byczyz/p/11588133.html
版权
什么是Spring

 Spring：SE/EE开发的一站式框架。

     一站式框架：有EE开发的每一层解决方案。

　　　　 WEB层 ：SpringMVC

　　　　  Service层 ：Spring的Bean管理，Spring声明式事务

　　　　 DAO层 ：Spring的Jdbc模板，Spring的ORM模块

为什么学习Spring

 Spring的入门（IOC）

什么IOC？

IOC: Inversion of Control(控制反转)。

　　控制反转：将对象的创建权反转给（交给）Spring。

下载Spring的开发包

官网:http://spring.io/

 

 docs ：Spring的开发规范和API

libs ：Spring的开发的jar和源码

schema ：Spring的配置文件的约束

创建web项目，引入jar包

 

创建接口和类

问题：如果底层的实现切换了，需要修改源代码，能不能不修改程序源代码对程序进行扩展？

将实现类交给Spring管理

在spring的解压路径下spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html

 

编写测试类

编写userDAO和userDAOImp

userDAO

public interface userDAO {
    public void save();
}

 userDAOImp

public class userDAOImp implements userDAO {
    @Override
    public void save() {
        System.out.println("userDAOImp执行了......");
    }
}

 设置spring的xml applicationContext.xml   可以随意命名

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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">
<!--spring入门的配置-->
    <bean id="userDAO" class="spring.learn.userDAOImp">
    
    </bean>
</beans>

 最后编写SpringDemo1对功能进行实现

package spring.learn;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringDemo1 {
    //传统的调用方式
    public void demo1(){
        userDAO userDAO=new userDAOImp();
        userDAO.save();
    }
    //Spring的方式的调用
    public void demo2(){
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        userDAO userDAO=(userDAO)applicationContext.getBean("userDAO");
        userDAO.save();
    }

    public static void main(String[] args) {
        SpringDemo1 springDemo1=new SpringDemo1();
        springDemo1.demo1();
        springDemo1.demo2();
    }
}

结果显示

IOC和DI（*****）

IOC：控制反转，将对象的创建权反转给了Spring。
DI：依赖注入，前提必须有IOC的环境，Spring管理这个类的时候将类的依赖的属性注入（设置）进来。
面向对象的时候
依赖
Class A{

}

Class B{
    public void xxx(A a){

}
}
继承:is a
Class A{

}
Class B extends A{

}

Spring的工厂类

Spring工厂类的结构图

ApplicationContext继承BeanFactory

　　　　BeanFactory：老版本的工厂类        BeanFactory：调用getBean的时候，才会生成类的实例。

 ApplicationContext：新版本的工厂类

ApplicationContext：加载配置文件的时候，就会将Spring管理的类都实例化。

ApplicationContext有两个实现类

ClassPathXmlApplicationContext：加载类路径下的配置文件

FileSystemXmlApplicationContext ：加载文件系统下的配置文件

Bean的相关配置

<bean>标签的id和name的配置

　　id :使用了约束中的唯一约束。里面不能出现特殊字符的。

        name :没有使用约束中的唯一约束（理论上可以出现重复的，但是实际开发不能出现的）。里面可以出现特殊字符。

           Spring和Struts1框架整合的时候

           <bean name=”/user” class=””/>

1Bean的生命周期的配置（了解）

        init-method :Bean被初始化的时候执行的方法

  • destroy-method :Bean被销毁的时候执行的方法（Bean是单例创建，工厂关闭）

Bean的作用范围的配置（重点）

scope    :Bean的作用范围 

  1. singleton：默认的，Spring会采用单例模式创建这个对象。
  2.  prototype：多例模式。（Struts2和Spring整合一定会用到）
  3.  request ：应用在web项目中，Spring创建这个类以后，将这个类存入到request范围中。
  4. session ：应用在web项目中，Spring创建这个类以后，将这个类存入到session范围中。
  5.  globalsession ：应用在web项目中，必须在porlet环境下使用。但是如果没有这种环境，相对于session

 Spring的Bean实例化方式（了解）

Bean已经都交给Spring管理，Spring创建这些类的时候，有几种方式：

无参构造的方式（默认）

编写无参构造类 

public class Bean1 {
    public Bean1(){
        System.out.println("Bean1的无参构造方法执行了......");
    }
}
<!--配置无参构造方法-->
    <bean id="bean1" class="spring.learn.demo1.Bean1"></bean>

实现功能

public class SpringDemo1 {
    public static void main(String[] args) {
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Bean1 bean1=(Bean1) applicationContext.getBean("bean1");
    }
}

静态工厂实例化方式

 配置

实例工厂实例化的方式

 配置

 Spring的属性注入

构造方法属性注入

编写类

public class Car {
    public String name;
    public double price;
    public Car(String name,double price){
        this.name=name;
        this.price=price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}
 <!--构造方法的方式注入-->
    <bean id="car" class="spring.learn.demo2.Car">
        <constructor-arg name="name" value="宝马" />
        <constructor-arg name="price" value="800000" />
    </bean>

实现

public class SpringDemo2 {
    public static void main(String[] args) {
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Car car=(Car)applicationContext.getBean("car");
        System.out.println(car.toString());
    }
}

set方法方式的属性注入

public class Car2 {
    public String name;
    public double price;

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

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car2{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

 配置

<!--Set方法的方式的属性注入-->
    <bean id="car2" class="spring.learn.demo2.Car2">
        <property name="name" value="奔驰" />
        <property name="price" value="10000000000" />
    </bean>

 实现方式

public class SpringDemo2 {
    public static void main(String[] args) {
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Car2 car2=(Car2)applicationContext.getBean("car2");
        System.out.println(car2.toString());
    }
}

set方法设置对象类型的属性

public class Employee {
    public String name;
    public Car2 car2;

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

    public void setCar2(Car2 car2) {
        this.car2 = car2;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", car2=" + car2 +
                '}';
    }
}

配置

<!--Set方法的方式的属性注入-->
    <bean id="car2" class="spring.learn.demo2.Car2">
        <property name="name" value="奔驰" />
        <property name="price" value="10000000000" />
    </bean>

    <!--Set方法设置对象类型的属性-->
    <bean id="employee" class="spring.learn.demo2.Employee">
        <!--Value:设置普通类型的值，ref设置其他类的id或者name-->
        <property name="name" value="zyz" />
        <property name="car2" ref="car2" />
    </bean>

实现

public class SpringDemo3 {
    public static void main(String[] args) {
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Employee employee=(Employee)applicationContext.getBean("employee");
        System.out.println(employee.toString());
    }
}

 P名称空间的属性注入（Spring2.5以后）

　　　　通过引入p名称空间完成属性的注入：

　　　　　　写法：

　　　　　　　　普通属性 p:属性名=”值”

　　　　　　　　对象属性 p:属性名-ref=”值

 p名称空间的引入

使用p名称空间

 SpEL的属性注入（Spring3.0以后）

     SpEL：Spring Expression Language，Spring的表达式语言。

 

集合类型属性注入（了解）

<!-- 注入数组类型 -->

 

import java.util.Arrays;

public class CollectionBean {
    public String arr[];
    public void setArr(String[] arr) {
        this.arr = arr;
    }
    @Override
    public String toString() {
        return "CollectionBean{" +
                "arr=" + Arrays.toString(arr) +
                '}';
    }
}
<!--注入数组类型-->
    <bean id="collectionBean" class="spring.learn.demo2.CollectionBean">
        <!--数组类型的-->
        <property name="arr">
            <list>
                <value>王东</value>
                <value>赵洪</value>
                <value>李冠希</value>
            </list>
        </property>
    </bean>
public void arrdemo1(){
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        CollectionBean collectionBean=(CollectionBean)applicationContext.getBean("collectionBean");
        System.out.println(collectionBean.toString());
    }

 

 

<!--注入list集合-->

import java.util.List;

public class ListBean {
    public List list;
    public void setList(List list) {
        this.list = list;
    }
    @Override
    public String toString() {
        return "ListBean{" +
                "list=" + list +
                '}';
    }
}
<!--注入list集合-->
    <bean id="listBean" class="spring.learn.demo2.ListBean">
        <property name="list">
            <list>
                <value>王东</value>
                <value>赵洪</value>
                <value>李冠希</value>
            </list>
        </property>
    </bean>
public void listdemo1(){
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        ListBean listBean=(ListBean)applicationContext.getBean("listBean");
        System.out.println(listBean.toString());
    }

 

注入Set集合

import java.util.Set;

public class SetBean {
    public Set set;

    public void setSet(Set set) {
        this.set = set;
    }
    @Override
    public String toString() {
        return "SetBean{" +
                "set=" + set +
                '}';
    }
}
<!--注入Set集合-->
    <bean id="setBean" class="spring.learn.demo2.SetBean">
        <property name="set">
            <set>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </set>
        </property>
    </bean>
public void setdemo1(){
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        SetBean setBean=(SetBean)applicationContext.getBean("setBean");
        System.out.println(setBean.toString());
    }

 

注入Map集合

import java.util.Map;

public class MapBean {
    public Map map;
    public void setMap(Map map) {
        this.map = map;
    }

    @Override
    public String toString() {
        return "MapBean{" +
                "map=" + map +
                '}';
    }
}
<!--注入Map集合-->
    <bean id="mapBean" class="spring.learn.demo2.MapBean">
        <property name="map">
            <map>
                <entry key="aaa" value="111"/>
                <entry key="bbb" value="222"/>
                <entry key="ccc" value="333"/>
            </map>
        </property>
    </bean>
public void mapdemo1(){
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        MapBean mapBean=(MapBean)applicationContext.getBean("mapBean");
        System.out.println(mapBean.toString());
    }

 

Spring的分模块开发的配置

在加载配置文件的时候，加载多个

 

 

在一个配置文件中引入多个配置文件

 

转载于:https://www.cnblogs.com/byczyz/p/11588133.html

weixin_30312659
关注
Spring框架入门
Princess_Y
11-24 3545
文章目录Spring第1章 简介==1.1 Spring概述==Spring的下载地址1.3 Spring模块==Spring框架分为五大模块：==1.4 HelloWorld==applicationContext.xml文件中的内容====1.5 获取bean的方式==第2章 基于XML的方式管理Bean2.1 IOC和DI2.1.1 IOC(Inversion of Control)：反转控制2.1.2 DI(Dependency Injection)：依赖注入==2.1.3 IOC容器在Spring
Spring Cloud 从入门到精通
热门推荐
GitChat
07-03 79万+
Spring Cloud 是一套完整的微服务解决方案，基于 Spring Boot 框架，准确的说，它不是一个框架，而是一个大的容器，它将市面上较好的微服务框架集成进来，从而简化了开发者的代码量。 本课程由浅入深带领大家一步步攻克 Spring Cloud 各大模块，接着通过一个实例带领大家了解大型分布式微服务架构的搭建过程，最后深入源码加深对它的了解。 本课程共分为四个部分： 第一部分（第...
SpringCloud入门教程（全集）
tttalk的博客
03-01 9万+
SpringCloud所有常见组件介绍及使用示例
Spring常用注解（绝对经典）
学Java，找哪吒
07-14 17万+
Spring注解方式减少了配置文件内容，更加便于管理，并且使用注解可以大大提高了开发效率！
Java--Spring入门
MinggeQingchun的博客
06-03 941
一、Spring简介 （一）简介 Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，它是为了解决企业应用开发的复杂性而创建的 Spring 的核心是控制反转（IoC）和面向切面编程（AOP）。Spring 是可以在 Java SE/EE 中使用的轻量级开源框架 简而言之：Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架 Spring 的主要作用就是为代码“解耦”，降低代码间的耦合度 Spring官网：https://spring.io/ .
Spring Boot常用注解（绝对经典）
学Java，找哪吒
07-16 17万+
一、Spring常用注解 Spring常用注解（绝对经典） 二、Jpa 1、@Entity ，@Table(name="") 表明这是一个实体类，一般用于jpa，这两个注解一块使用，但是如果表名和实体类名相同的话，@Table可以省略。 2、@MappedSuperClass 基于代码复用和模型分离的思想，在项目开发中使用jpa的@MappedSuperClass注解，将实体类的多个属性分别封装到不同的非实体类中。例如，数据库表中都需要id来表示编号，id是这些映射实体类的通用属性，交给jpa统
Spring 入门教程
Oneby的博客
03-01 1万+
Spring 入门教程 1、参考资料 尚硅谷-Spring5框架最新版教程（idea版） 雷丰阳spring、springmvc、mybatis、spring一站式学习 项目地址：oneby1314/spring-learn 2、Spring 概述 2.1、Spring 框架概述 Spring 是轻量级的开源的 JavaEE 框架 Spring 为简化企业级开发而生，使用Spring，Javabean就可以实现很多以前要靠EJB才能实现的功能 Spring 有两个核心部分：IOC 和 AOP
Spring入门教程
weixin_58642210的博客
12-12 1841
目录 工厂模式 1.什么是框架？ 2.Spring的优势 3.举个User小例子 IOC控制反转 beans 单例模式 工厂模式 把原来分布在各个地方的对象创建的过程都单独抽离出来，统一交给工厂类来负责所需对象的创建 1.什么是框架？ 1.1框架本身一般不完整 1.2在里面进行填充扩展，迎合公司的业务需求，做公司的项目 1.3为了更好的适合大多数项目，不断进行扩展，扩充的东西就是类库 2.Spring的优势 2.1方便解耦，简化开发 Spring就是一个大工厂，可以将所有..
Elasticsearch入门及常用命令和Spring中的常用操作
花木凋零成兰的博客
03-26 3057
Elasticsearch快速入门、以及常用命令介绍；学习Spring中整合Elasticsearch；解决Elasticsearch与Redis的Netty冲突，介绍Spring中常用的Elasticsearch操作API，以及复杂查询等。
Spring 最全入门教程详解
lucky_fd的博客
07-04 7487
Spring 基础框架，可以视为Spring 基础设施，基本上任何其他 Spring 项目都是以 SpringFramework 为基础的。Spring 5 的模块结构图: lOC: Inversion of Control，翻译过来是反转控制。把对象创建和对象之间的调用过程，交给 Spring 进行管理Spring 的IOC 容器就是IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建 bean 之前，首先需要创建IOC容器。Spring 提供了IOC容器的两种实现方式：
Spring入门.pdf
02-17
总的来说，"Spring入门.pdf"这篇教程将引导你进入Spring的世界，了解其基本概念、依赖注入的原理以及如何使用SpringMVC和SpringBoot构建现代Java应用。此外，SSM框架的介绍将帮助你理解如何在实际项目中整合这些组件...
spring入门经典源代码
04-13
本资源"Spring入门经典源代码"旨在帮助初学者快速理解并掌握Spring框架的核心概念和使用方法。这本书籍结合了丰富的示例代码，使得理论与实践相结合，使学习过程更加直观和高效。 1. **Spring概述** Spring是一个...
Spring Boot入门初体验
06-19
Boot入门初体验是一门针对初学者准备的课程，讲解了如何一步一步进入Spring?Boot开发，课程采用循序渐进的方式，一个知识点一个知识点的讲解和学习，让初学者不知不觉的掌握各种开发技能，课程包含了主流框架搭建、...
spring入门案例所需工具
01-08
通过这个"spring入门案例所需工具"的压缩包，你将找到一些基本的配置文件、示例代码和教程，它们将帮助你更好地理解和应用上述知识。开始你的Spring之旅，你会发现这个框架的强大和灵活性，为你的Java开发带来无尽的...
Java企业面试题3
m0_74972727的博客
09-15 891
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
Arthas sysenv（查看JVM的环境变量）
最新发布
刘大猫
09-21 192
Arthas sysenv（查看JVM的环境变量）
JDK17新增语法特性
2201_76124988的博客
09-20 524
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 176
faiss版本 faiss-v1.7.4。
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 914
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值