一：指定bean的依赖关系
例如examplebean对象依赖examplebean1对象，那么在创建examplebean对象之前就
需要先创建examplebean1对象。
1：创建Examplebean1类：
/**
*
*/
package com.hlcui.dao; /**
* @author Administrator
*
*/
public class ExampleBean1 {
public ExampleBean1() {
System.out.println("实例化ExampleBean1...");
}
}
2：在spring容器配置文件中配置ExampleBean1对象，并且指定bean的依赖关系
depends-on="ExampleBean1"
<!-- 实例化ExampleBean对象 -->
<bean id="exampleBean" class="com.hlcui.dao.ExampleBean" lazy-init="true"
init-method="init" destroy-method="destroy" scope="singleton" depends-on="ExampleBean1"></bean> <!-- 实例化ExampleBean1对象 -->
<bean id="ExampleBean1" class="com.hlcui.dao.ExampleBean1"
lazy-init="true"></bean>
3：运行测试方法：
@Test
/**测试bean的依赖关系*/
public void testNewExampleBean() {
ApplicationContext ac = getApplicationContext();
ExampleBean eb1 = ac.getBean("exampleBean", ExampleBean.class);
System.out.println(eb1);
}
通过结果可以看出先实例化依赖对象，再创建对象。
二：spring实现setter注入到jdbcDatasource数据库连接参数
1：导入jar包，在spring原有的支持包的基础上导入，oracle数据库的驱动包
2：创建JDBCDataSource类
/**
*
*/
package com.hlcui.dao; import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException; /**
* @author Administrator
*
*/
public class JDBCDataSource { private String driverClass; private String url; private String username; private String password; public String getDriverClass() {
return driverClass;
} public void setDriverClass(String driverClass) {
try {
Class.forName(driverClass); // 注册数据库驱动
this.driverClass = driverClass;
} catch (ClassNotFoundException e) {
e.printStackTrace();
} } public String getUrl() {
return url;
} public void setUrl(String url) {
this.url = url;
} public String getUsername() {
return username;
} public void setUsername(String username) {
this.username = username;
} public String getPassword() {
return password;
} public void setPassword(String password) {
this.password = password;
} // 获取数据库连接
public Connection getConn() throws SQLException {
return DriverManager.getConnection(url, username, password);
} // 关闭数据库连接
public void closeConn(Connection conn) {
if (null != conn) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
3：配置bean对象
核心代码如下：
<!-- 配置jdbc数据源 -->
<bean id="jdbcDatasource" class="com.hlcui.dao.JDBCDataSource">
<property name="driverClass" value="oracle.jdbc.OracleDriver"></property>
<property name="url" value="jdbc:oracle:thin:@localhost:1521:orcl"></property>
<property name="username" value="system"></property>
<property name="password" value="orcl"></property>
</bean>
4：测试方法以及运行结果
@Test
/**测试获取jdbc连接*/
public void testJdbcConnection() {
try {
ApplicationContext ac = getApplicationContext();
JDBCDataSource ds = ac.getBean("jdbcDatasource",
JDBCDataSource.class);
System.out.println(ds.getConn());
} catch (Exception e) {
e.printStackTrace();
} }
从运行结果可以看出，得到了jdbc连接对象。
三：spring实现构造器注入参数
1：创建业务实体类对象User
/**
*
*/
package com.hlcui.dto; /**
* @author Administrator
*
*/
public class User {
private int id;
private String name;
private String pwd;
private String phone;
public User(int id, String name, String pwd, String phone) {
super();
this.id = id;
this.name = name;
this.pwd = pwd;
this.phone = phone;
}
public User(String name, String pwd, String phone) {
super();
this.name = name;
this.pwd = pwd;
this.phone = phone;
}
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;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((phone == null) ? 0 : phone.hashCode());
result = prime * result + ((pwd == null) ? 0 : pwd.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
User other = (User) obj;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (phone == null) {
if (other.phone != null)
return false;
} else if (!phone.equals(other.phone))
return false;
if (pwd == null) {
if (other.pwd != null)
return false;
} else if (!pwd.equals(other.pwd))
return false;
return true;
}
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + ", phone=" + phone
+ ", pwd=" + pwd + "]";
} }
2：创建oracle的sql脚本，并且执行sql
--创建表users
Create Table Users(
Id Number(6,2),
Name Varchar2(30),
Pwd Varchar2(50),
Phone Varchar2(50),
Primary Key(Id),
constraint name unique(name)
); --创建序列
Create Sequence Seq_Users; --向表中插入数据
Insert Into Users (Id,Name,Pwd,Phone) Values(Seq_Users.Nextval,'Tom','','');
Insert Into Users (Id,Name,Pwd,Phone) Values(Seq_Users.Nextval,'Jack','','');
Insert Into Users (Id,Name,Pwd,Phone) Values(Seq_Users.Nextval,'Lucy','','');
commit;
3：创建UserDAO接口以及其实现类
package com.hlcui.dao; import com.hlcui.dto.User; /**
* @author Administrator
*
*/
public interface UserDAO {
public User findByName(String name);
}
/**
*
*/
package com.hlcui.dao.impl; import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet; import com.hlcui.dao.JDBCDataSource;
import com.hlcui.dao.UserDAO;
import com.hlcui.dto.User; /**
* @author Administrator
*
*/
public class OracleUserDAO implements UserDAO { private JDBCDataSource jdbcDataSource; public OracleUserDAO(JDBCDataSource jdbcDataSource) {
this.jdbcDataSource = jdbcDataSource;
} public User findByName(String name) {
Connection conn = null;
PreparedStatement prep = null;
ResultSet rs = null;
User user = null;
try {
conn = jdbcDataSource.getConn();
String sql = "select id,pwd,phone from users where name=?";
prep = conn.prepareStatement(sql);
prep.setString(1, name);
rs = prep.executeQuery();
while (rs.next()) {
int id = rs.getInt("id");
String pwd = rs.getString("pwd");
String phone = rs.getString("phone");
user = new User(id, name, pwd, phone);
}
} catch (Exception e) {
e.printStackTrace();
}
return user;
} }
注：这里使用preparedstatement进行预编译，可以有效的防止sql注入，select * from tableName where username='' and password = '' or 1=1,
这里的1=1是无论什么条件都会满足的，所以会登录进网站。经常使用ibatis框架的朋友对 where 1=1 and ... 比较熟悉，这里是为了防止后面的sql动态拼接
不满足条件造成 select * from tableName where 这种情况，这里区分一下。
4：在spring容器配置文件配置OracleUserDao的bean对象
<!-- 配置jdbc数据源 -->
<bean id="jdbcDatasource" class="com.hlcui.dao.JDBCDataSource">
<property name="driverClass" value="oracle.jdbc.OracleDriver"></property>
<property name="url" value="jdbc:oracle:thin:@localhost:1521:orcl"></property>
<property name="username" value="system"></property>
<property name="password" value="orcl"></property>
</bean> <!-- 配置userDao对象 -->
<bean id="userDao" class="com.hlcui.dao.impl.OracleUserDAO">
<constructor-arg index="0" ref="jdbcDatasource"/>
</bean>
constructor-arg元素代表构造器注入，index是参数的下表，0说明是第一个元素，如果有多个参数，可以使用如下格式：
<constructor-arg index="0">
<value>first parameter</value>
</constructor-arg>
<constructor-arg index="1">
<value>second parameter</value>
</constructor-arg>
5：测试读取数据库中的user对象
@Test
/**测试从oracle数据库中读取数据*/
public void testGetUser() {
ApplicationContext ac = getApplicationContext();
UserDAO dao = ac.getBean("userDao", OracleUserDAO.class);
User user = dao.findByName("Tom");
System.out.println(user);
}
成功读取User对象！