⑴ java连接数据库DAO
再写一个类，声明一个List类的方法，先调用DAO方法，然后用迭代器(Iterator)迭代结果
⑵ Java连接数据库为什么要用Dao
我的理解只是为了封装，方便业务层组装调用来完成业务，这样代码的结构会比较好
你说的DAO是 做的一层专门负责数据库操作的逻辑层，具体你是hibernate,ibatis,jdbc你没说，所以不便于回答。
用的hibernate的话 getSession.update(String sql,Object params);
⑷ java如何通过Dao接口取得数据库数据【谢谢】
import java.util.List;
import com.icss.xxx.domain.User;
public interface UserDAO {
public int login(User user);
public User queryUser(String userId) throws Exception;
public int updateUser(User user);
public int addUser(User user);
public int deleteUser(String userId) throws Exception;
public List getAllUsers();
public User getUser(String userName) throws Exception;
}
---------------------------------------
下面是实现类
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import com.xxx.xxx.common.ConnectionFactory;
import com.xxx.xxx.common.DatabaseUtils;
import com.xxx.xxx..UserDAO;
import com.xxx.xxx.domain.User;
public class UserDAOImpl implements UserDAO {
public List getAllUsers() {
Connection conn=ConnectionFactory.getConnection();
List users=new ArrayList();
Statement stmt=null;
ResultSet rs=null;
try {
stmt=conn.createStatement();
rs=stmt.executeQuery("select * from training");
User user=null;
while(rs.next()){
user=new User();
user.setUserId(rs.getString("userid"));
user.setUserName(rs.getString("username"));
user.setUserPass(rs.getString("userpass"));
users.add(user);
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
DatabaseUtils.release(rs, stmt, conn);
}
return users;
}
public int login(User user) {
int flag=0;
Connection conn=ConnectionFactory.getConnection();
PreparedStatement pstm=null;
ResultSet rs=null;
try {
pstm=conn.prepareStatement("select * from train_user where user_name=? and user_pass=?");
pstm.setString(1, user.getUserName());
pstm.setString(2, user.getUserPass());
rs=pstm.executeQuery();
if(rs.next()){
if(rs.getString("admin").equals("1")){
flag=1;
}else if(rs.getString("admin").equals("0")){
flag=2;
}else{
flag=0;
};
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
DatabaseUtils.release(rs, pstm, conn);
}
return flag;
}
public User queryUser(String userId) {
Connection conn = ConnectionFactory.getConnection();
PreparedStatement pstm = null;
ResultSet rs = null;
User user = null;
try {
pstm = conn.prepareStatement("select * from test where userid=?");
pstm.setString(1, userId);
rs = pstm.executeQuery();
if(rs.next()){
user = new User();
user.setUserId(rs.getString("userid"));
user.setUserName(rs.getString("username"));
user.setUserPass(rs.getString("userPass"));
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
DatabaseUtils.release(rs, pstm, conn);
}
return user;
}
public int updateUser(User user) {
Connection conn = ConnectionFactory.getConnection();
PreparedStatement pstm = null;
ResultSet rs = null;
int flag = 0;
try {
pstm = conn.prepareStatement("update test set username=?, userpass=? where userid=?");
pstm.setString(1, user.getUserName());
pstm.setString(2, user.getUserPass());
pstm.setString(3, user.getUserId());
flag = pstm.executeUpdate();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
DatabaseUtils.release(rs, pstm, conn);
}
return flag;
}
public int addUser(User user) {
Connection conn=ConnectionFactory.getConnection();
PreparedStatement pstm=null;
int flag=0;
try {
pstm=conn.prepareStatement("insert into train_user(user_id,user_name,user_pass,train_id,train_nature,admin) values(?,?,?,?,?,0)");
pstm.setString(1,user.getUserId());
pstm.setString(2,user.getUserName());
pstm.setString(3,user.getUserPass());
pstm.setString(4,user.getTrain_id());
pstm.setString(5,user.getTrain_nature());
pstm.executeUpdate();
flag=1;
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
DatabaseUtils.release(null, pstm, conn);
}
return flag;
}
public int deleteUser(String userId) throws Exception {
Connection conn = ConnectionFactory.getConnection();
PreparedStatement pstm = null;
int flag = 0;
try {
pstm = conn.prepareStatement("delete from test where userid=?");
pstm.setString(1, userId);
flag = pstm.executeUpdate();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
DatabaseUtils.release(null, pstm, conn);
}
return flag;
}
public User getUser(String userName) throws Exception {
// TODO Auto-generated method stub
return null;
}
}
⑸ java中如何实现登录界面与数据库正确连接
使用JDBC进行数据库的增删改查操作1.下载Microsoft SQL Server 2005 JDBC 驱动包jar文件 将jar文件引入工程中2.封装数据库链接的获取和关闭操作import java.sql.*;public class BaseDao {
/**
* 数据库驱动类的字符串,完整的包名加类名 在工程中查看添加的jar文件 能看到这个类
*/
private static final String DRIVE = "com.microsoft.sqlserver.jdbc.SQLServerDriver"; /**
* 数据库连接地址
*
* DataBaseName=数据库名称 其它固定
*/
private static final String URL = "jdbc:sqlserver://localhost:1433;DataBaseName=bbs"; /**
* 连接数据库的用户名
*/
private static final String USER = "sa"; /**
* 用户密码
*/
private static final String PASSWORD = ""; /**
* 获取连接 异常直接抛出 或者捕获后自定义异常信息再抛出
*/
public static Connection getConnection() throws Exception {
Class.forName(DRIVE);
return DriverManager.getConnection(URL, USER, PASSWORD);
} /**
* 关闭与数据库的连接 释放资源
*/
public static void closeAll(ResultSet resultSet, PreparedStatement pst,
Connection connection) throws Exception {
if (resultSet != null)
resultSet.close();
if (pst != null)
pst.close();
if (connection != null)
connection.close();
}}3.创建图书的实体类public class Book {
/**
* 数据库主键
*/
private Long id; /**
* 作者
*/
private String author; /**
* 书名
*/
private String name;
/**
* 默认构造
*
*/
public Book() {
}
/**
* 全字段构造
* @param id
* @param author
* @param name
*/
public Book(Long id, String author, String name) {
this.id = id;
this.author = author;
this.name = name;
}
/**
* 以下为读写属性的方法
* @return
*/
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
4.创建与图书表交互的工具类import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;public class BookDao {
/**
* 添加新书
*
* @param book 要添加入数据库的图书 作者 书名 必须给定
*/
public void addBook(Book book) throws Exception {
// 连接
Connection connection = null;
// 执行语句
PreparedStatement pst = null;
try {
connection = BaseDao.getConnection();
// 构造执行语句
String sql = "insert into book values(" + book.getAuthor() + ","
+ book.getName() + ")";
pst = connection.prepareStatement(sql);
pst.executeUpdate(); } catch (Exception e) {
// 抛出异常
throw e;
} finally {
// 无论是否异常 均关闭数据库
BaseDao.closeAll(null, pst, connection);
}
} /**
* 查询所有书籍列表
*/
public List<Book> getBooks() throws Exception {
// 用于存放查寻结果的集合
List<Book> books = new ArrayList<Book>();
// 连接
Connection connection = null;
// 执行语句
PreparedStatement pst = null;
// 查询结果
ResultSet resultSet = null;
try {
connection = BaseDao.getConnection();
// 构造查询语句
String sql = "select * from book";
pst = connection.prepareStatement(sql);
resultSet = pst.executeQuery(); // 循环读取查询结果行
while (resultSet.next()) {
// getXXX的参数为数据表列名
Book book = new Book(resultSet.getLong("id"), resultSet
.getString("author"), resultSet.getString("name"));
// 将封装好的图书对象存入集合
books.add(book);
}
} catch (Exception e) {
// 抛出异常
throw e;
} finally {
// 无论是否异常 均关闭数据库
BaseDao.closeAll(resultSet, pst, connection);
}
// 返回查询结果
return books;
}/***其它方法类似上面 只是语句不同*/
}当然 以上只是简单的封装 初学者可以在理解以上代码的基础上 进行更高级的封装
5.使用BookDao添加书籍和获取所有书籍列表import java.util.List;/**
* 测试类
* @author Administrator
*
*/
public class Test { /**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
//创建工具类对象
BookDao = new BookDao();
//创建一本图书
Book book = new Book(null,"QQ:495691293","编程菜鸟");
//添加书籍到数据库
.addBook(book);
//获取所有图书列表
List<Book> books = .getBooks();
//输出结果
for (Book b : books) {
System.out.println(b.getId()+"\t"+b.getAuthor()+"\t"+b.getName());
}
}}
⑹ java关于操作数据库
用Hibernate。Hibernate可以根据实体类和配置文件自动生成sql语句，这样只用写一个通用的DAO然后其他DAO继承它后就自然有对应的增删改查功能了。比如我的DAO一般就
@Repository("brandDAO")
public class BrandDAO extends HibernateDao<Integer> {
}
⑺ 刚学java 操作数据库，不太懂
Dao层是Java web的三层架构的持久化层。Dao 的工厂类是用来创建的对象。采用的时工厂模式。我比较常用的时用单例模式来创建的对象。至于Dao借口，如果你只是一个测试的东东，力求简化，这个当然可以去去掉的。但是你如果是做开发项目，你就会发现这个的用处。
还有，现在开发web项目都会使用框架了，比如spring框架，就可以建立相当明晰的三层框架。
这是我用spring建立的一个web的简单项目的框架结构。domain是ORM映射类，数据库操作类，持久层，service是服务层，提供事务管理可工作流程的控制，web层拦截请求，返回结果。
⑻ java中，用DAO查询一个数据库步骤，分哪几个步骤，原理解析
创建一个以JDBC连接数据库的程序，包含7个步骤：
1、加载JDBC驱动程序：
在连接数据库之前，首先要加载想要连接的数据库的驱动到JVM（Java虚拟机），
这通过java.lang.Class类的静态方法forName(String className)实现。
例如：
try{
//加载MySql的驱动类
Class.forName("com.mysql.jdbc.Driver") ;
}catch(ClassNotFoundException e){
System.out.println("找不到驱动程序类 ，加载驱动失败！");
e.printStackTrace() ;
}
成功加载后，会将Driver类的实例注册到DriverManager类中。
2、提供JDBC连接的URL
•连接URL定义了连接数据库时的协议、子协议、数据源标识。
•书写形式：协议：子协议：数据源标识
协议：在JDBC中总是以jdbc开始
子协议：是桥连接的驱动程序或是数据库管理系统名称。
数据源标识：标记找到数据库来源的地址与连接端口。
例如：（MySql的连接URL）
jdbc:mysql:
//localhost:3306/test?useUnicode=true&characterEncoding=gbk ;
useUnicode=true：表示使用Unicode字符集。如果characterEncoding设置为
gb2312或GBK，本参数必须设置为true 。characterEncoding=gbk：字符编码方式。
3、创建数据库的连接
•要连接数据库，需要向java.sql.DriverManager请求并获得Connection对象，
该对象就代表一个数据库的连接。
•使用DriverManager的getConnectin(String url , String username ,
String password )方法传入指定的欲连接的数据库的路径、数据库的用户名和
密码来获得。
例如：
//连接MySql数据库，用户名和密码都是root
String url = "jdbc:mysql://localhost:3306/test" ;
String username = "root" ;
String password = "root" ;
try{
Connection con =
DriverManager.getConnection(url , username , password ) ;
}catch(SQLException se){
System.out.println("数据库连接失败！");
se.printStackTrace() ;
}
4、创建一个Statement
•要执行SQL语句，必须获得java.sql.Statement实例，Statement实例分为以下3
种类型：
1、执行静态SQL语句。通常通过Statement实例实现。
2、执行动态SQL语句。通常通过PreparedStatement实例实现。
3、执行数据库存储过程。通常通过CallableStatement实例实现。
具体的实现方式：
Statement stmt = con.createStatement() ;
PreparedStatement pstmt = con.prepareStatement(sql) ;
CallableStatement cstmt =
con.prepareCall("{CALL demoSp(? , ?)}") ;
5、执行SQL语句
Statement接口提供了三种执行SQL语句的方法：executeQuery 、executeUpdate
和execute
1、ResultSet executeQuery(String sqlString)：执行查询数据库的SQL语句
，返回一个结果集（ResultSet）对象。
2、int executeUpdate(String sqlString)：用于执行INSERT、UPDATE或
DELETE语句以及SQL DDL语句，如：CREATE TABLE和DROP TABLE等
3、execute(sqlString):用于执行返回多个结果集、多个更新计数或二者组合的
语句。
具体实现的代码：
ResultSet rs = stmt.executeQuery("SELECT * FROM ...") ;
int rows = stmt.executeUpdate("INSERT INTO ...") ;
boolean flag = stmt.execute(String sql) ;
6、处理结果
两种情况：
1、执行更新返回的是本次操作影响到的记录数。
2、执行查询返回的结果是一个ResultSet对象。
• ResultSet包含符合SQL语句中条件的所有行，并且它通过一套get方法提供了对这些
行中数据的访问。
• 使用结果集（ResultSet）对象的访问方法获取数据：
while(rs.next()){
String name = rs.getString("name") ;
String pass = rs.getString(1) ; // 此方法比较高效
}
（列是从左到右编号的，并且从列1开始）
7、关闭JDBC对象
操作完成以后要把所有使用的JDBC对象全都关闭，以释放JDBC资源，关闭顺序和声
明顺序相反：
1、关闭记录集
2、关闭声明
3、关闭连接对象
if(rs != null){ // 关闭记录集
try{
rs.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
if(stmt != null){ // 关闭声明
try{
stmt.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
if(conn != null){ // 关闭连接对象
try{
conn.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
⑼ java怎么连接mysql数据库
这里介绍两种方式：
一，jdbc链接MySQL数据库：
1，如果你用jdbc方式，则按照下列方式进行连接：
A，注册驱动
B，链接数据库
C，执行sql
D，返回结果集
如下为一个基本完整流程：
packagecom.hu.demo;
importjava.sql.Connection;
importjava.sql.DriverManager;
importjava.sql.PreparedStatement;
importjava.sql.SQLException;
publicclassDBHelper{
publicstaticfinalStringurl="jdbc:mysql://127.0.0.1/student";
publicstaticfinalStringname="com.mysql.jdbc.Driver";
publicstaticfinalStringuser="root";
="root";
publicConnectionconn=null;
publicPreparedStatementpst=null;
publicDBHelper(Stringsql){
try{
Class.forName(name);//指定连接类型
conn=DriverManager.getConnection(url,user,password);//获取连接
pst=conn.prepareStatement(sql);//准备执行语句
}catch(Exceptione){
e.printStackTrace();
}
}
publicvoidclose(){
try{
this.conn.close();
this.pst.close();
}catch(SQLExceptione){
e.printStackTrace();
}
}
}
2，将注册，链接封装好，执行sql语句，返回结果集，代码如下：
packagecom.hu.demo;
importjava.sql.ResultSet;
importjava.sql.SQLException;
publicclassDemo{
staticStringsql=null;
staticDBHelperdb1=null;
staticResultSetret=null;
publicstaticvoidmain(String[]args){
sql="select*fromstuinfo";//SQL语句
db1=newDBHelper(sql);//创建DBHelper对象
try{
ret=db1.pst.executeQuery();//执行语句，得到结果集
while(ret.next()){
Stringuid=ret.getString(1);
Stringufname=ret.getString(2);
Stringulname=ret.getString(3);
Stringudate=ret.getString(4);
System.out.println(uid+" "+ufname+" "+ulname+" "+udate);
}//显示数据
ret.close();
db1.close();//关闭连接
}catch(SQLExceptione){
e.printStackTrace();
}
}
}
3，查询结果如下：
<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">
<!--配置数据源-->
<beanname="dataSource"class="com.alibaba.druid.pool.DruidDataSource"
init-method="init"destroy-method="close">
<propertyname="url"value="${jdbc_url}"/>
<propertyname="username"value="${jdbc_username}"/>
<propertyname="password"value="${jdbc_password}"/>
<!--初始化连接大小-->
<propertyname="initialSize"value="0"/>
<!--连接池最大使用连接数量-->
<propertyname="maxActive"value="20"/>
<!--连接池最小空闲-->
<propertyname="minIdle"value="0"/>
<!--获取连接最大等待时间-->
<propertyname="maxWait"value="60000"/>
<!--<propertyname="poolPreparedStatements"value="true"/><property
name=""value="33"/>-->
<propertyname="validationQuery"value="${validationQuery}"/>
<propertyname="testOnBorrow"value="false"/>
<propertyname="testOnReturn"value="false"/>
<propertyname="testWhileIdle"value="true"/>
<!--配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒-->
<propertyname="timeBetweenEvictionRunsMillis"value="60000"/>
<!--配置一个连接在池中最小生存的时间，单位是毫秒-->
<propertyname="minEvictableIdleTimeMillis"value="25200000"/>
<!--打开removeAbandoned功能-->
<propertyname="removeAbandoned"value="true"/>
<!--1800秒，也就是30分钟-->
<propertyname="removeAbandonedTimeout"value="1800"/>
<!--关闭abanded连接时输出错误日志-->
<propertyname="logAbandoned"value="true"/>
<!--监控数据库-->
<!--<propertyname="filters"value="stat"/>-->
<propertyname="filters"value="mergeStat"/>
</bean>
<!--myBatis文件-->
<beanid="sqlSessionFactory"class="org.mybatis.spring.SqlSessionFactoryBean">
<propertyname="dataSource"ref="dataSource"/>
<!--自动扫描entity目录,省掉Configuration.xml里的手工配置-->
<propertyname="mapperLocations"value="classpath:com/fourfaith/*/mapping/*.xml"/>
</bean>
<beanclass="org.mybatis.spring.mapper.MapperScannerConfigurer">
<propertyname="basePackage"value="com.fourfaith.**."/>
<propertyname="sqlSessionFactoryBeanName"value="sqlSessionFactory"/>
</bean>
<!--配置事务管理器-->
<beanid="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<propertyname="dataSource"ref="dataSource"/>
</bean>
<!--拦截器方式配置事物-->
<tx:adviceid="transactionAdvice"transaction-manager="transactionManager">
<tx:attributes>
<tx:methodname="add*"propagation="REQUIRED"/>
<tx:methodname="append*"propagation="REQUIRED"/>
<tx:methodname="insert*"propagation="REQUIRED"/>
<tx:methodname="save*"propagation="REQUIRED"/>
<tx:methodname="update*"propagation="REQUIRED"/>
<tx:methodname="modify*"propagation="REQUIRED"/>
<tx:methodname="edit*"propagation="REQUIRED"/>
<tx:methodname="delete*"propagation="REQUIRED"/>
<tx:methodname="remove*"propagation="REQUIRED"/>
<tx:methodname="repair"propagation="REQUIRED"/>
<tx:methodname="delAndRepair"propagation="REQUIRED"/>
<tx:methodname="import*"propagation="REQUIRED"read-only="false"
rollback-for="java.lang.Exception"/>
<tx:methodname="get*"propagation="SUPPORTS"/>
<tx:methodname="find*"propagation="SUPPORTS"/>
<tx:methodname="load*"propagation="SUPPORTS"/>
<tx:methodname="search*"propagation="SUPPORTS"/>
<tx:methodname="datagrid*"propagation="SUPPORTS"/>
<tx:methodname="*"propagation="SUPPORTS"/>
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcutid="transactionPointcut"
expression="execution(*com...*.service..*Impl.*(..))"/>
<aop:advisorpointcut-ref="transactionPointcut"
advice-ref="transactionAdvice"/>
</aop:config>
<!--配置druid监控springjdbc-->
<beanid="druid-stat-interceptor"
class="com.alibaba.druid.support.spring.stat.DruidStatInterceptor">
</bean>
<beanid="druid-stat-pointcut"class="org.springframework.aop.support.JdkRegexpMethodPointcut"
scope="prototype">
<propertyname="patterns">
<list>
<value>com...*.service.*</value>
</list>
</property>
</bean>
<aop:config>
<aop:advisoradvice-ref="druid-stat-interceptor"
pointcut-ref="druid-stat-pointcut"/>
</aop:config>
</beans>
还有很多方式可以实现，这里就简略的描述一番。
⑽ java中Dao如何访问数据库
用java访问数据库需要4步骤，只要按这个做就可以轻松访问数据库。
1、加载数据库驱动
2、获得数据库连接
3、执行sql语句
4、（处理结果集）
5、关闭资源
第4歩看你的sql语句了，如果有返回结果则有第4歩，否则不用。
具体的：用一个类做例子
public class UserDaoImpl{
public void insertUserMessage(String name,String pwd){
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
//上面是加载数据库驱动
String url="jdbc:oracle:thin:@localhost:1521:orcl";
//orcl为数据库的SID
String user="test";//这个是数据库的登录用户名
String password="test"; //登录密码
Connection conn =DriverManager.getConnection (url,user,password);
//获得数据库连接
PreparedStatement pst = conn.prepareStatement("Sql语句");
pst.setString(1,name);
pst.setString(2,pwd);
pst.excute();
pst.close();//关闭资源
conn.close();
}
}
以上就是连接数据库的伪码，不知道对你有没有帮助