Spring02 HelloSpring

2021-03-25 11:00:47 阅读：169 来源： 互联网

标签：xml String age HelloSpring Spring02 context public name

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9