首页 > 其他分享> > Spring02 HelloSpring

Spring02 HelloSpring

2021-03-25 11:00:47 作者：互联网

HelloSpring

导包

注 : spring 需要导入commons-logging进行日志记录 . 我们利用maven , 他会自动下载对应的依赖项

 <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.12.RELEASE</version>
        </dependency>
    </dependencies>

创建实体类

public class User {
 private String name;
 private int age;

 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;
 }

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

编写我们的spring文件 , 这里我们命名为applicationContext.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">
    <!--使用Spring来创建对象，在Spring中称之为bean-->
    <!-- Hello hello=new Hello();
        id=变量名；
        class=new的对象
        property相当于给对象中的属性设值
    -->
    <bean id="user" class="com.phx.entity.User">
        <property name="name" value="张三"></property>
        <property name="age" value="25"></property>
    </bean>
</beans>

测试代码

 public static void main(String[] args) {
        //获取Spring的上下文对象！,解析applicationContext.xml配置文件，生成管理相应的bean对象
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        //getBean（）：参数为spring配置文件中bean的id
        User user = context.getBean("user",User.class);
        System.out.println(user.toString());
    }

思考

User对象是谁创建的 ? 【user对象是由Spring创建的
Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的
这个过程就叫控制反转 :
- 控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
- 反转 : 程序本身不创建对象 , 而变成被动的接收对象 .
  依赖注入 : 就是利用set方法来进行注入的.
  IOC是一种编程思想，由主动的编程变成被动的接收

修改的案例一

我们在案例一中，新增一个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="userDaoImpl" class="com.phx.dao.UserDaoImpl"></bean>
    <bean id="userDaoImpl2" class="com.phx.dao.UserDaoImpl2"></bean>
    <bean id="userServiceImpl" class="com.phx.service.UserServiceImpl">
        <!--ref:应用Spring容器创建好的对象
        value：具体的值 基本数据类型
        -->
        <property name="userDao" ref="userDaoImpl2"></property>
    </bean>
</beans>

测试

public class MyTest2 {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
        UserServiceImpl userServiceImpl = context.getBean("userServiceImpl", UserServiceImpl.class);
        userServiceImpl.getUser();
    }
}

现在 , 我们彻底不用再程序中去改动了 , 要实现不同的操作 , 只需要在xml配置文件中进行修改 , 所谓的IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配

IOC创建对象方式

通过无参构造方法来创建

//配置文件
<?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="user2" class="com.phx.entity.User2">
     <property name="name" value="phx"></property>
 </bean>
</beans>
//实体类
public class User2 {
    private String name;

    public String getName() {
        return name;
    }

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

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

}
//测试方法
public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("beans2.xml");
        //在执行getBean的时候, user已经创建好了 , 通过无参构造
        User2 user2 = context.getBean("user2", User2.class);
        //调用对象的方法 toString
        System.out.println(user2);//User2{name='phx'}
    }

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

通过有参构造方法来创建

//配置文件
<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">
    <!-- 第一种根据index参数下标设置 -->
    <!--<bean id="user3" class="com.phx.entity.User3">-->
    <!-- index指构造方法 , 下标从0开始 -->
        <!--<constructor-arg index="0" value="zs" ></constructor-arg>-->
        <!--<constructor-arg index="1" value="18" ></constructor-arg>-->
    <!--</bean>-->

    <!-- 第二种根据参数名字设置 -->
    <!--<bean id="user3" class="com.phx.entity.User3">-->
        <!--&lt;!&ndash; name指参数名 &ndash;&gt;-->
        <!--<constructor-arg name="name" value="zs"></constructor-arg>-->
        <!--<constructor-arg name="age" value="18"></constructor-arg>-->
    <!--</bean>-->
    <!-- 第三种根据参数类型设置 -->
    <bean id="user3" class="com.phx.entity.User3">
        <constructor-arg type="java.lang.String" value="zs"></constructor-arg>
        <constructor-arg type="int" value="18"></constructor-arg>
    </bean>
</beans>
//实体类
public class User3 {
    private String name;
    private int age;

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

    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;
    }

    @Override
    public String toString() {
        return "User3{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//测试类
public class MyTest3 {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("beans3.xml");
        //在执行getBean的时候, user已经创建好了 
        User3 user3 = context.getBean("user3", User3.class);
        //调用对象的方法 toString
        System.out.println(user3);//User3{name='zs', age=18}
    }
}

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

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

<!--设置别名：在获取Bean的时候可以使用别名获取-->
 <alias name="user3" alias="as"></alias>
    <bean id="user3" class="com.phx.entity.User3">
        <constructor-arg type="java.lang.String" value="zs"></constructor-arg>
        <constructor-arg type="int" value="18"></constructor-arg>
    </bean>
 //测试类
  public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("beans3.xml");
        //没有配合别名只能通过bean的id获取，否则报错 ：No bean named 'as' available
        User3 user3 = context.getBean("as", User3.class);
        //调用对象的方法 toString
        System.out.println(user3);//User3{name='zs', age=18}
    }

Bean的配置

 <!--bean就是java对象,由Spring创建和管理-->
    <!--
        id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
        如果配置id,又配置了name,那么name是别名
        name可以设置多个别名,可以用逗号,分号,空格隔开
        如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;
        class是bean的全限定名=包名+类名
    -->
    <bean id="user3" name="as,sa" class="com.phx.entity.User3">
        <constructor-arg type="java.lang.String" value="zs"></constructor-arg>
        <constructor-arg type="int" value="18"></constructor-arg>
    </bean>

import团队的合作通过import来实现

	<beans>
	...
	<import resource="beans.xml"></import>
	</beans>
//测试类
 public static void main(String[] args) {

		//获取beans3.xml配置时通过<import resource="beans.xml"></import>获取beans.xml的配置
        ApplicationContext context=new ClassPathXmlApplicationContext("beans3.xml");
        //没有配合别名只能通过bean的id获取，否则报错 ：No bean named 'as' available
        User3 user3 = context.getBean("sa", User3.class);
        //调用对象的方法 toString
        System.out.println(user3);//User3{name='zs', age=18}
        //调用UserServiceImpl类的对象service实现getUser（）方法
        UserServiceImpl service=context.getBean("userServiceImpl",UserServiceImpl.class);//获取其他信息
        service.getUser();
    }

标签：xml,String,age,HelloSpring,Spring02,context,public,name
来源： https://blog.csdn.net/weixin_42367504/article/details/115190763