spring的入门

最新推荐文章于 2024-11-04 22:26:34 发布
最新推荐文章于 2024-11-04 22:26:34 发布
阅读量125 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/huasonglin/p/8287895.html
版权

一、使用spring的五个步骤

目录结构：

1.1、添加spring-context依赖

pom.xml

    <!--第一步：添加spring-context依赖-->
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.12.RELEASE</version>
        </dependency>

    </dependencies>

1.2、创建xml文件

1.3、配置bean

spring.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">

    <!--第二步：创建xml文件-->
    <!--第三步：配置bean-->
    <bean id="stu" class="entity.Student"/>

</beans>

1.4、实例化上下文类

 Student.java

package entity;

/*第四步：实例化上下文类*/
public class Student {
    public Student() {
        System.out.println("student的构造方法");
    }
    public void test(){
        System.out.println("spring的测试");
    }
}

1.5、getBean得到对象

main.java

package entity;

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

public class mian {
    public static void main(String[] args) {
        /*第五步：getBean得到对象*/
        //超级工厂
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Student student = (Student) applicationContext.getBean("stu");
        student.test();
    }
}

二、别名和分隔符

配置bean时，id是唯一的，当然也可以用name指定别名来标记，可写多个别名，可用“，”，“；”，“空格”隔开。注：id和name都是唯一的，不可重复

事例：

    <!--三种分隔符分别是：,;空格-->
    <!--允许使用不同分隔符隔开-->
    <bean id="stu" name="aaa,bbb;ccc eee" class="entity.Student"/>

使用方法和id一样：

package entity;

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

public class Main {
    public static void main(String[] args) {

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

        Student student = (Student) applicationContext.getBean("stu");
        student.test();

        Student aaa = (Student) applicationContext.getBean("aaa");
        aaa.test();

        Student bbb = (Student) applicationContext.getBean("bbb");
        bbb.test();

        Student ccc = (Student) applicationContext.getBean("ccc");
        ccc.test();

        Student eee = (Student) applicationContext.getBean("eee");
        eee.test();
  
    }
}

 三、spring创建对象的四种方法

 方法一：直接创建

spring.xml

<bean id="stu" class="entity.Student"/>

 Main.java

package entity;

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

public class Main {
    public static void main(String[] args) {

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

        Student student = (Student) applicationContext.getBean("stu");
        student.test();

    }
}

 方法二：静态工厂

spring.xml

<!--静态工厂-->
<bean id="entityFactory" class="factory.EntityFactory" factory-method="getStudent"/>

EntityFactory.java

package factory;

import entity.Student;
public class EntityFactory {
    //静态工厂
    public static Student getStudent(){
        return new Student();
    }
}

Main.java

package entity;

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

public class Main {
    public static void main(String[] args) {

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

        Student student = (Student) applicationContext.getBean("entityFactory");
        student.test();

    }
}

方法三：实例工厂

spring.xml

　　 <!--实例工厂-->
    <bean name="factory" class="factory.EntityFactory"/>
    <bean name="entityFactory2" class="factory.EntityFactory" factory-bean="factory" factory-method="getTeacher"/>

EntityFactory.java

package factory;

import entity.Student;
import entity.Teacher;

public class EntityFactory {
    //实例工厂
    public Teacher getTeacher(){
        return new Teacher();
    }
}

Main.java

package entity;

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

public class Main {
    public static void main(String[] args) {

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

        Teacher teacher = (Teacher) applicationContext.getBean("entityFactory2");
        teacher.test();

    }
}

方法四：使用FactoryBean创建工厂

StudentFactory.java

package factory;

import entity.Student;
import org.springframework.beans.factory.FactoryBean;

public class StudentFactory implements FactoryBean<Student> {
    public Student getObject() throws Exception {
        return new Student();
    }

    public Class<?> getObjectType() {
        return Student.class;
    }

    public boolean isSingleton() {
        return false;
    }
}

spring.xml

<!--FactoryBean-->
<bean id="studentFactory" class="factory.StudentFactory"/>

Main.java

package entity;

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

public class Main {
    public static void main(String[] args) {

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

        Student student = (Student) applicationContext.getBean("studentFactory");
        student.test();

    }
}

四、初始化与销毁的三种方法 

方法一：直接在bean中定义init-method="方法名"（初始化）；destory-method="方法名"（销毁）

<bean id="stu" class="entity.Student" init-method="init" destroy-method="end"/>

方法二：在beans中定义default-init-method=“方法名”（初始化）；default-destory-method=“方法名”（销毁）

<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.xsd"
       default-init-method="init" default-destroy-method="end"
>

    <bean id="stu" class="entity.Student" />

方法三：在实体类实现InitializingBean（初始化）；DisposableBean（销毁）

注：如果在实体类实现初始化、销毁方法与在beans中定义，则先运行在实体类定义的初始化、销毁方法，在实体类中定义的优先级更高。

Student.java

package entity;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class Student implements InitializingBean,DisposableBean {
    
    public void afterPropertiesSet() throws Exception {
        System.out.println("after properties set----");
    }

    public void destroy() throws Exception {
        System.out.println("destory----");
    }
}

spring.xml

<bean id="stu" class="entity.Student" "/> 

五、依赖注入（DI：Dependency inject）（又称：控制反转 Inversion of Control ，缩写：IoC）

依赖注入的种类：

1、 setter方式的注入

Teacher.class

package IoC;

import java.util.List;
import java.util.Map;

public class Teacher {
    private String name;
    private List<String> students;
    private int age;
    private Object aa;
    private Map<String,String> bbb;

    public List<String> getStudents() {
        return students;
    }

    public void setStudents(List<String> students) {
        this.students = students;
    }

    public void info(){
        System.out.println(this.name);
        System.out.println(this.students);
        System.out.println(this.age);
        System.out.println(this.aa);
        System.out.println(this.bbb);
    }

    public int getAge() {
        return age;
    }

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

    public Object getAa() {
        return aa;
    }

    public void setAa(Object aa) {
        this.aa = aa;
    }

    public Map<String, String> getBbb() {
        return bbb;
    }

    public void setBbb(Map<String, String> bbb) {
        this.bbb = bbb;
    }
}

1.1、给集合设值的三种方式（set、list、props、map）

list:数据可重复

<?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="tea" class="IoC.Teacher">
        <property name="students">      <!--給集合設值-->
            <!--使用list-->
            <list>
                <value>小張</value>
                <value>小李</value>
                <value>小紅</value>
                <value>小白</value>
            </list>
        </property>
    </bean>
</beans>

set:会去除重复的数据

<?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="tea" class="IoC.Teacher">
        <property name="students">      <!--給集合設值-->
            <!--使用set-->
            <set>
                <value>小紅</value>
                <value>小紅</value>
                <value>小張</value>
                <value>小里</value>
            </set>
        </property>
    </bean>
</beans>

map:

<?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="tea" class="IoC.Teacher">
        <property name="bbb">
            <!--使用map給集合設值-->
            <map>
                <entry key="name" value="zss"/>
                <entry key="age" value="18"/>
                <entry key="sex" value="men"/>
            </map>

    </bean>

</beans>

props:

<?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="tea" class="IoC.Teacher">
        <property name="bbb">
            <!--使用props給集合設值-->
            <props>
                <prop key="name">zss</prop>
                <prop key="age">123</prop>
            </props>
        </property>

    </bean>

</beans>

1.2、直接给字段设值

<property name="age" value="111"> </property>

1.3、设值空值

<property name="aa"><null></null></property>

1.4、内部bean：通过内部的bean来给类的字段设值

A.class

package IoC;

public class A {
    private B b;
    public B getB() {
        return b;
    }
    public void setB(B b) {
        this.b = b;
    }
    public void get(){
        System.out.println(this.b.getName());
    }
}

B.class

package IoC;

public class B {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

bean.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">

    <bean class="IoC.A" id="a">
        <property name="b">
            <bean class="IoC.B">
                <property name="name" value="張三三"/>
            </bean>
        </property>
    </bean>

</beans>

2、 构造函数方式的注入

2.1、给构造函数设值（单个值和集合）

Teacher.class

package IoC;

import java.util.List;
import java.util.Map;

public class Teacher {
    private String name;
    private List<String> students;

    public Teacher(String name,List<String> students) {
        this.name = name;
        this.students = students;
    }

    public void info(){
        System.out.println(this.name);
        System.out.println(this.students);
    }

}

teacher.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">

    <bean id="tea" class="IoC.Teacher">
        <constructor-arg index="0" value="張老師"/>  <!--給構造函數設置-->
        <constructor-arg index="1">     <!--給構造函數賦集合的值-->
            <list>
                <value>小紅</value>
                <value>小小李</value>
                <value>小白</value>
            </list>
        </constructor-arg>
    </bean>

</beans>

 

转载于:https://www.cnblogs.com/huasonglin/p/8287895.html

dibaotui0692
关注
Spring入门
行者无疆的博客
03-19 1897
1 Spring 简介 1.1 Spring 概述 官网定义： Spring 框架为任何类型的部署平台上的基于 Java 的现代企业应用程序提供了全面的编程和配置模型。 Spring 的一个关键元素是在应用程序级别的基础架构支持：Spring 专注于企业应用程序的 “管道”，以便团队可以专注于应用程序级别的业务逻辑，而不必与特定的部署环境建立不必要的联系。 慕课解释： 简单来说：Spring 是一个免费开源框架，为了简化企业级项目开发，提供全面的开发部署解决方案。 1.2 Spring 的体系结构 结构图
Spring入门教程
weixin_58642210的博客
12-12 1868
目录 工厂模式 1.什么是框架？ 2.Spring的优势 3.举个User小例子 IOC控制反转 beans 单例模式 工厂模式 把原来分布在各个地方的对象创建的过程都单独抽离出来，统一交给工厂类来负责所需对象的创建 1.什么是框架？ 1.1框架本身一般不完整 1.2在里面进行填充扩展，迎合公司的业务需求，做公司的项目 1.3为了更好的适合大多数项目，不断进行扩展，扩充的东西就是类库 2.Spring的优势 2.1方便解耦，简化开发 Spring就是一个大工厂，可以将所有..
JAVA之Spring入门导读
tq02的博客
04-22 1409
详细介绍Spring是什么，以及学习路线
Spring入门第一讲——Spring框架的快速入门
热门推荐
李阿昀的博客
04-08 14万+
Spring的概述什么是Spring据度娘所载： Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。 Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Exp
Spring入门程序
weixin_54013954的博客
12-11 1090
spring是当前主流的JavaWeb框架，它是为了解决应用开发复杂性问题而产生的。对于一个Java应用程序员来说，掌握spring框架的使用，是我们基本的一项技能。
Spring概述与核心概念学习 -- Spring入门（一）
HHX_01的博客
04-24 1万+
Spring Framework 是一个功能强大的 Java 应用程序框架，旨在提供高效且可扩展的开发环境。它结合了轻量级的容器（IOC）和依赖注入(DI)功能，提供了一种使用 POJO 进行容器配置和面向切面的编程的简单方法，以及一组用于AOP(切面编程)的模块。Spring 框架还支持各种移动应用开发技术，如 Android 和 iOS。
Spring入门，看这篇就够了
m0_54928777的博客
06-17 3529
一篇对Spring入门案例演示的文章，仅供正在学习Spring的小伙伴们参考哟！
使用Eclipse 开发Spring入门程序
m0_46814663的博客
08-21 3348
在上述main方法中并没有使用new运算符创建TestDaoImpl类的对象，而是通过Spring容器来获取实现类对象，这就是IoC的工作机制。首先使用Eclipse创建一个Web应用（项目），将Spring的4个基础包和第三方依赖包commons-logging-1.2.jar复制到WEB-INF/lib目录中。1、打开文件：spring-framework-4.3.6.RELEASE>docs>spring-framework-reference>html>index.html。Spring解决的是。
Educoder Spring入门 第一关：Hello Spring
于建章的博客
10-01 3041
Spring入门
IDEA环境配置及Spring入门
YouthBlood9的博客
09-13 2122
IDEA环境配置及Spring入门–以HelloWorld为例的简单介绍与开发步骤前言：本文主要内容一：IDEA环境配置二：用传统Java编程方式写HelloWorld例子传统java：不使用框架1.先构建一个新项目2.在新建的项目src下建立beans包，新建java class：HelloWorld、Main三：用Spring框架写HelloWorld例子1. 什么是Spring2. 开发步骤（基于IDEA）构建新项目分三步进行总结：对Spring的作用的初步了解参考文献 前言：本文主要内容 安装J
spring入门
12-23
让我们从这个"spring入门"的描述出发，深入探讨Spring的核心概念和技术。 1. **依赖注入（Dependency Injection，DI）**：Spring 的核心特性之一是依赖注入，它允许开发者在运行时将对象之间的依赖关系进行管理。...
spring入门相关jar包
11-21
spring入门相关jar包，相关jar包为： commons-logging-1.2.jar spring-beans-5.2.6.RELEASE.jar spring-context-5.2.6.RELEASE.jar spring-core-5.2.6.RELEASE.jar spring-expression-5.2.6.RELEASE.jar
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 647
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
spring循环依赖解决方式
qq_36400213的博客
11-04 794
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 269
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
Qt自定义控件：汽车速度表
weixin_44788175的博客
11-02 414
从外到内进行绘制，初始化画布，画渐变色外圈，画刻度，写刻度文字，画指针，画扇形，画内圈渐变色，画黑色内圈，写当前值。这里难点使用正弦和余弦计算绘制刻度字。
JAVA学习-练习试用Java实现“数组排序”
weixin_69763181的博客
11-03 273
这个程序首先导入了'java.util.Arrays'和'java.util.Scanner'，然后定义了一个'main'方法。程序使用'Scanner'类来读取用户的输入，并将其分割成一个字符串数组。然后，它将字符串数组转换成整数数组，并使用'Arrays.sort'方法对整数数组进行排序。以下是一个Java程序，它使用内置的'Arrays.sort'方法对用户输入的整数数组进行排序。编写一个Java程序，对用户输入的整数数组进行排序（可以使用内置的Arrays.sort方法，也可以自己实现排序算法）。
GEMM优化（待更新）
qq_62704693的博客
11-03 754
来源参考：深入浅出GPU优化系列：GEMM优化（一） - 知乎深入浅出GPU优化系列：GEMM优化（二） - 知乎深入浅出GPU优化系列：GEMM优化（三） - 知乎。
Spring入门：理论与实践指南
本资源是一份Spring入门教程，旨在帮助读者理解Spring框架的核心概念和实践应用。Spring是一个轻量级的Java企业级开发框架，以其依赖注入（Dependency Injection, DI）和控制反转（Inversion of Control, IoC）为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值