首页 > 编程语言> > Spring02：第一个Spring程序

Spring02：第一个Spring程序

2021-05-08 23:05:18 作者：互联网

1、HelloSpring

操作流程：

1、导入相应的依赖

 <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-webmvc</artifactId>
     <version>5.3.5</version>
</dependency>

2、编写实体类

package org.com.pojo;

public class Hello {
    private String name;
    
    public void show(){
        System.out.println("Hello " + name);
    }

    public String getName() {
        return name;
    }

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

3、编写spring配置文件，命名为beans.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
       https://www.springframework.org/schema/beans/spring-beans.xsd
       ">
    <bean id="hello" class="org.com.pojo.Hello">
        <property name="name" value="Spring"/>
    </bean>


</beans>

4、测试

@Test
public void test1(){
    //解析beans.xml文件 , 生成管理相应的Bean对象
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    //getBean : 参数即为spring配置文件中bean的id 
    Hello hello = context.getBean("hello", Hello.class);
    hello.show();

}

思考：

Hello 对象是谁创建的 ? 【hello 对象是由Spring创建的
Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的

这个过程就叫控制反转 :

控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
反转 : 程序本身不创建对象 , 而变成被动的接收对象 .

依赖注入 : 就是利用set方法来进行注入的.

IOC是一种编程思想，由主动的编程变成被动的接收

可以通过newClassPathXmlApplicationContext去浏览一下底层源码

2、修改上篇的案例

1、添加Spring配置文件

<?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
       https://www.springframework.org/schema/beans/spring-beans.xsd
       ">

    <bean id="mysql" class="org.com.dao.impl.UserDaoMysqlImpl"/>
    <bean id="oracle" class="org.com.dao.impl.UserDaoOracleImpl"/>

    <bean id="userServiceImpl" class="org.com.service.impl.UserServiceImpl">
        <property name="userDao" ref="mysql"/>
    </bean>


</beans>

2、测试

@Test
public void test2(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    UserServiceImpl userServiceImpl = context.getBean("userServiceImpl", UserServiceImpl.class);
    userServiceImpl.getUserList();

}

现在我们彻底不用在程序中去改动了，要实现不同的操作，只需在xml配置文件中修改，所谓的IOC，一句话总结：对象由Spring来创建，管理，装配！

3、IOC创建对象的方式

3.1、通过无参构造方法来创建

1、创建实体类

package org.com.pojo;

public class User {
    private String name;

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

    public void show(){
        System.out.println("我的名字是：" + name);
    }

    public String getName() {
        return name;
    }

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

2、配置bean

<bean id="user" class="org.com.pojo.User">
    <property name="name" value="Tim"/>
</bean>

3、测试

@Test
public void test2(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    User user = context.getBean("user", User.class);
    user.show();

}

结果可以发现，在调用show方法之前，User对象已经通过无参构造初始化了！

3.2通过有参构造方法来创建

1、实体类

package org.com.pojo;

public class User2 {

    private String name;

    public User2(String name){
        this.name = name;
        System.out.println("User2的有参构造");
    }

    public void show(){
        System.out.println("我的名字是：" + name);
    }

    public String getName() {
        return name;
    }

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

2、配置bean，有三种不同的方式

<bean id="user2" class="org.com.pojo.User2">
    <!-- 第一种根据index参数下标设置 -->
    <constructor-arg index="0" value="Jetty"/>
    <!-- 第二种根据参数名字设置 -->
    <constructor-arg name="name" value="Frank"/>
    <!-- 第三种根据参数类型设置，如果两个参数类型相同就不能用这中了 -->
    <constructor-arg type="java.lang.String" value="Lucky"/>
</bean>

3、测试

@Test
public void test3(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    User2 user2 = context.getBean("user2", User2.class);
    user2.show();

}

结论：在配置文件加载的时候。其中管理的对象都已经初始化了！

3.3、对象创建细节

1、scope属性：

指定scope属性，IOC容器就知道创建对象的时候是单例还是多例的了。
- 属性的值有四个：singleton/prototype/request/session
当我们使用singleton【单例】的时候，从IOC容器获取的对象都是同一个
当我们使用prototype【多例】的时候，从IOC容器获取的对象都是不同的
当使用singleton的时候，对象在IOC容器之前就已经创建了
当使用prototype的时候，对象在使用的时候才创建
request和session在web开发中才能用到

2、lazy-init属性：

lazy-init属性只对singleton【单例】的对象有效.....lazy-init默认为false....
想要对象在使用的时候才创建，那么将lazy-init设置为ture就行了

3、 init-method和destroy-method属性：

如果我们想要对象在创建后，执行某个方法，我们指定为init-method属性就行了
如果我们想要IOC容器销毁后，执行某个方法，我们指定destroy-method属性就行了

<bean id="user" class="User" scope="singleton" lazy-init="true" init-method="" destroy-method=""/>

小结：

对象创建：单例/多例
- scope="singleton", 默认值，即默认是单例【service/dao/工具类】
- scope="prototype", 多例；【Action对象】
什么时候创建?
- scope="prototype" 在用到对象的时候，才创建对象。
- scope="singleton" 在启动(容器初始化之前)，就已经创建了bean，且整个应用只有一个。
是否延迟创建
- lazy-init="false" 默认为false, 不延迟创建，即在启动时候就创建对象
- lazy-init="true" 延迟初始化，在用到对象的时候才创建对象（只对单例有效）
创建对象之后，初始化/销毁
- init-method="init_user" 【对应对象的init_user方法，在对象创建之后执行】
- destroy-method="destroy_user" 【在调用容器对象的destroy方法时候执行，(容器用实现类)】

4、Spring配置

4.1、别名

alias 设置别名 , 为bean设置别名 , 可以设置多个别名

<alias name="user" alias="user3"/>

4.2、bean的配置

<!--bean就是java对象,由Spring创建和管理-->

<!--
   id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
   如果配置id,又配置了name,那么name是别名
   name可以设置多个别名,可以用逗号,分号,空格隔开
   如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;
   class是bean的全限定名=包名+类名
-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

4.3、import

团队的合作通过import来实现

<import resource="{path}/beans.xml"/>

标签：name,对象,Spring,void,程序,Spring02,init,创建,public
来源： https://www.cnblogs.com/javaconner/p/14746794.html