一、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("添加操作执行成功");
}
}