第11章 Spring练习1

最新推荐文章于 2024-08-14 23:30:00 发布

Nefertari_______

最新推荐文章于 2024-08-14 23:30:00 发布

阅读量61

点赞数

文章标签： spring java 后端

本文链接：https://blog.csdn.net/Nefertari_______/article/details/130882348

版权

一、Spring环境配置

1.Spring IOC/DI

下载并导入lib包

准备pojo Category，用来演示IOC和DI。

package com.how2java.pojo;

public class Category {

		private int id;
		private String name;
		public int getId(){
			return id;
		}
		public void setId(int id){
			this.id=id;
		}
		
		public String getName(){
			return name;
		}
		public void setName(String name){
			this.name=name;
		}
}

配置applicationContext.xml文件

在src目录下新建applicationContext.xml文件，applicationContext.xml是Spring的核心配置文件，通过关键字c即可获取Category对象，该对象获取的时候，即被注入了字符串"category 1“到name属性中。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
   http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx 
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/context      
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 
    <bean name="c" class="com.how2java.pojo.Category">
        <property name="name" value="category 1" />
    </bean>
 
</beans>

测试代码，演示通过spring获取Category对象，以及该对象被注入的name属性。

package com.how2java.test;

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

import com.how2java.pojo.Category;

public class TestSpring {

	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "applicationContext.xml" });

		Category c = (Category) context.getBean("c");

		System.out.println(c.getName());
	}
}

2.Spring注入对象

创建实体类Product，Product类中有对Category对象的setter getter

在applicationContext.xml中增加一行

在创建Product的时候注入一个Category对象，注意，这里要使用ref来注入另一个对象

修改TestSpring.java，通过Spring拿到的Product对象已经被注入了Category对象了。

3.Spring注解方式IOC/DI

修改applicationContext.xml

在Product.java的category属性前加上@Autowired注解

运行结果如下图所示：

二、构造器和setter注入的方式给bean的属性赋值。

创建数据表user

1.Setter注入

配置文件中的<property>元素可以为JavaBean的Setter方法传参，即通过Setter方法为属性赋值。

创建User类

package com.mr.user;

public class User {
    
    private String name;//用户姓名
    private Integer age;//年龄
    private String sex;//性别

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

修改applicationContext.xml，配置该JavaBean。

<value>标签用于为name属性赋值，这是一个普通的赋值标签。直接在成对的<value>标签中放入数值或其他赋值标签，Spring会把这个标签提供的属性值注入指定的JavaBean中。

<bean name="user" class="com.mr.user.User">
		<property name="name">
			<value>无语</value>
		</property>
		<property name="age">
			<value>30</value>
		</property>
		<property name="sex">
			<value>女</value>
		</property>
	</bean>

创建ManagerServlet的Servlet，在其doGet()方法中，首先装载配置文件并获取Bean，然后通过Bean对象的相应方法获取并输出用户信息。

package com.mr.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

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

import com.mr.user.User;

/**
 * Servlet implementation class ManagerServlet
 */
@WebServlet("/ManagerServlet")
public class ManagerServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public ManagerServlet() {
        super();
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        ApplicationContext factory=new ClassPathXmlApplicationContext("applicationContext.xml"); //装载配置文件
        User user = (User) factory.getBean("user");                                    //获取Bean
        System.out.println("用户姓名——"+user.getName());//输出用户的姓名
        System.out.println("用户年龄——"+user.getAge());//输出用户的年龄
        System.out.println("用户性别——"+user.getSex());//输出用户的性别		
	}

}

运行结果：

2.构造器注入

它通过将一个类的依赖关系声明为该类的构造函数的参数，并在创建类的实例时提供它们来满足这些依赖关系。具体而言，构造器注入是指在一个类的构造函数中传入其他对象或接口实例，以在类中使用这些变量。

在类被实例化时，其构造方法被调用并且只能调用一次，所以构造器常被用于类的初始化操作。<constructor-arg>是<bean>元素的子元素，通过<constructor-arg>元素的<value>子元素可以构造方法传参。

package com.mr.user;

public class User {
    private String name;							//用户姓名
    private Integer age;							//年龄
    private String sex;								//性别
    //构造方法
    public User(String name,Integer age,String sex){
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
    //输出JavaBean的属性值方法
    public void printInfo(){
        System.out.println("用户姓名——"+name);		//输出用户的姓名
        System.out.println("用户年龄——"+age);			//输出用户的年龄
        System.out.println("用户性别——"+sex);			//输出用户的性别
    }
}

<?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-3.0.xsd">
	<!-- User Bean -->
	<bean name="user" class="com.mr.user.User">
		<constructor-arg>
			<value>无语</value>
		</constructor-arg>
		<constructor-arg>
			<value>30</value>
		</constructor-arg>
		<constructor-arg>
			<value>女</value>
		</constructor-arg>
	</bean>

</beans>

package com.mr.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

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

import com.mr.user.User;

/**
 * Servlet implementation class ManagerServlet
 */
@WebServlet("/ManagerServlet")
public class ManagerServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public ManagerServlet() {
        super();
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        ApplicationContext factory=new ClassPathXmlApplicationContext("applicationContext.xml"); //装载配置文件
        User user = (User) factory.getBean("user");            				//获取Bean
        user.printInfo();												//输出JavaBean的属性值
	}

}

运行结果如下图：

构造器注入方式的优点：

构造器注入的方式可以将所有依赖一次性注入，即在程序未完全初始化的状态下，注入对象不会被调用；此外对象也不可能再次被重新注入。

对于注入类型的选择并没有硬性的规定，对于那些My源代码的第三方类或者没有提供Setter方法的遗留代码，只能选择构造器注入方式实现依赖注入。

三、Spring的DAO模式

目前Spring DAO提供了如下抽象类：

①JdbcDaoSupport：JDBC DAO抽象类，开发人员需要为其设置数据源（DataSource），通过子类能够获得JdbcTemPlate来访问数据库。

②HibernateDaoSupport：Hibernate DAO抽象类，开发人员需要为其配置Hibernate SessionFactory，通过其子类能够获得Hibernate实现。

③JdoDaoSupport：Spring未JDO提供的DAO抽象类，开发人员需要为它配置PersistenceManagerFactory，通过其子类能够获得JdoTemplate。

实例中DAO模式实现的示意图如下：

例11-5，在Spring中利用DAO模式在tb_user表中添加数据。

package com.mr.dao;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

import javax.sql.DataSource;

import com.mr.user.User;

public class UserDAO implements UserDAOImpl {
    private DataSource dataSource;//注入DataSource
    public DataSource getDataSource() {
        return dataSource;
    }
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    //向数据表tb_user中添加数据
    public void inserUser(User user) {
        String name = user.getName();//获取姓名
        Integer age = user.getAge();//获取年龄
        String sex = user.getSex();//获取性别
        Connection conn = null;//定义Connection
        Statement stmt = null;//定义Statement   
         try {
             conn = dataSource.getConnection();//获取数据库连接
             stmt = conn.createStatement();
             stmt.execute("INSERT INTO tb_user (name,age,sex) " 
                  + "VALUES('"+name+"','" + age + "','" + sex + "')");//添加数据的SQL语句
         } catch (SQLException e) {
             e.printStackTrace();
         }
         finally {
             if(stmt != null) {
                 try {
                     stmt.close();//关闭Statement对象
                 }   
                 catch(SQLException e) {
                     e.printStackTrace();
                 }
             }
             if(conn != null) {
                 try {
                     conn.close();//关闭数据库连接
                 }
                 catch(SQLException e) {
                     e.printStackTrace();
                 }
             }
         }
    }
}

package com.mr.dao;

import com.mr.user.User;

public interface UserDAOImpl {
    public void inserUser(User user);//添加用户信息的方法
}

package com.mr.main;

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

import com.mr.dao.UserDAO;
import com.mr.user.User;

public class Manager {
    
    public static void main(String[] args) {
        ApplicationContext factory = new ClassPathXmlApplicationContext("applicationContext.xml");            //装载配置文件
        User user = new User();//实例化User对象
        user.setName("明日");//设置姓名
        user.setAge(new Integer(30));//设置年龄
        user.setSex("男");//设置性别
        UserDAO userDAO = (UserDAO) factory.getBean("userDAO");//获取UserDAO
        userDAO.inserUser(user);//执行添加方法
        System.out.println("数据添加成功!!!");          
    }
}

package com.mr.user;

public class User {
    
    private Integer id;//唯一性标识
    
    private String name;//姓名
    
    private Integer age;//年龄
    
    private String sex;//性别

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }  
}

<?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-2.5.xsd">
	<!-- 配置数据源 -->
	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName">
			<value>com.mysql.jdbc.Driver</value>
		</property>
		<property name="url">
			<value>jdbc:mysql://localhost:3306/test
			</value>
		</property>
		<property name="username">
			<value>root</value>
		</property>
		<property name="password">
			<value>123456</value>
		</property>
	</bean>
	<!-- 为UserDAO注入数据源 -->
	<bean id="userDAO" class="com.mr.dao.UserDAO">
		<property name="dataSource">
			<ref local="dataSource"/>
		</property>
	</bean>
</beans>

运行结果，不知道为什么报404的错误

四、应用Spring的DI技术，应用JdbcTemplate操作数据库

<?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-2.5.xsd">
	<!-- 配置数据源 -->
	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName">
			<value>com.mysql.jdbc.Driver</value>
		</property>
		<property name="url">
			<value>jdbc:mysql://localhost:3306/test
			</value>
		</property>
		<property name="username">
			<value>root</value>
		</property>
		<property name="password">
			<value>10KGyuye21</value>
		</property>
	</bean>
	<!-- 配置jdbcTemplate -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource">
			<ref local="dataSource"/>
		</property>
	</bean>
</beans>

package com.mr.main;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
 
public class AddUser {
    //利用JdbcTemplate添加数据
    public static void main(String[] args) {
        JdbcTemplate jtl = null;
        ApplicationContext factory = new ClassPathXmlApplicationContext("applicationContext.xml");
        jtl =(JdbcTemplate)factory.getBean("jdbcTemplate");
        String sql = "insert into tb_user(name,age,sex) values ('MING','23','FEMALE')";
        jtl.update(sql);
        System.out.println("添加操作执行成功");
    }
}

Nefertari_______

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第11章 Spring练习1

在src目录下新建applicationContext.xml文件，applicationContext.xml是Spring的核心配置文件，通过关键字c即可获取Category对象，该对象获取的时候，即被注入了字符串"category 1“到name属性中。对于注入类型的选择并没有硬性的规定，对于那些My源代码的第三方类或者没有提供Setter方法的遗留代码，只能选择构造器注入方式实现依赖注入。测试代码，演示通过spring获取Category对象，以及该对象被注入的name属性。
复制链接

扫一扫