最近在做项目的时候，对java连接到数据库小有体会，特此来写一篇博客给大家讲解在java中如何连接使用数据库。来展示下效果图：

 

    

     

         首先，我们来编写关于数据库里的数据操作，包括基本的增删查改以及增加的功能。我在数据库里定义了一个info库，并在库里添加了player表。player表内容如下：



可以看到，表里定义了三个变量int型scores，char类型的name与password。我写了一个 MyDBConnection类，来连接数据库，代码如下：

 

package dates;

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

public class MyDBConnection{//连接类

	private String DBDriver;
	private String DBURL;
	private String DBUser;
	private String DBPass;
	private Connection conn=null;
	private Statement stmt=null;
	public MyDBConnection(){
		DBDriver="com.mysql.jdbc.Driver";
		DBURL="jdbc:mysql://localhost:3306/info";
		DBUser="root";//用户名
		DBPass="473721601";//数据库密码
		try{
			Class.forName(DBDriver);//加载驱动程序
			//System.out.println("数据库驱动程序加载成功");
		}catch(Exception e){
			e.printStackTrace();
		}
		try{
			conn=DriverManager.getConnection(DBURL,DBUser,DBPass);//取得连接对象
			stmt=conn.createStatement();//取得SQL语句对象
			System.out.print("连接数据库成功");
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	public Connection getMyConnection(){
		return conn;
	}
	public Statement getMyStatement(){
		return stmt;
	}
	public void closeMyConnection(){//关闭数据库连接
		try{
			stmt.close();
			conn.close();
		}catch(SQLException e){
			e.printStackTrace();
		}
	}
	public String toString(){
		return "数据库驱动程序"+DBDriver+"，链接地址"+DBURL+"，用户名"+DBUser+"，密码"+DBPass;
	}
}//连接类

	private String DBDriver;
	private String DBURL;
	private String DBUser;
	private String DBPass;
	private Connection conn=null;
	private Statement stmt=null;
	public MyDBConnection(){
		DBDriver="com.mysql.jdbc.Driver";
		DBURL="jdbc:mysql://localhost:3306/info";
		DBUser="root";//用户名
		DBPass="473721601";//数据库密码
		try{
			Class.forName(DBDriver);//加载驱动程序
			//System.out.println("数据库驱动程序加载成功");
		}catch(Exception e){
			e.printStackTrace();
		}
		try{
			conn=DriverManager.getConnection(DBURL,DBUser,DBPass);//取得连接对象
			stmt=conn.createStatement();//取得SQL语句对象
			System.out.print("连接数据库成功");
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	public Connection getMyConnection(){
		return conn;
	}
	public Statement getMyStatement(){
		return stmt;
	}
	public void closeMyConnection(){//关闭数据库连接
		try{
			stmt.close();
			conn.close();
		}catch(SQLException e){
			e.printStackTrace();
		}
	}
	public String toString(){
		return "数据库驱动程序"+DBDriver+"，链接地址"+DBURL+"，用户名"+DBUser+"，密码"+DBPass;
	}
}

数据库连接成功后会显式数据库已连接成功。

         

 

         再来看看怎么样对数据库中的数据进行操作的：

 

	public void insertData(String name,String password,int scores){//插入操作
		try{
			String newType1=new String(name.getBytes(),"GBK");//字节转码
			String newType2=new String(password.getBytes(),"GBK");
			String sql="INSERT INTO player(scores,name,password)VALUES("+scores+",'"+newType1+"','"+newType2+"')";
			stmt.executeUpdate(sql);//更新语句
		}catch(Exception e1){
			e1.printStackTrace();
		}
	}
	

getBytes()让String对象转换为“GBK”的字节码，并可以插入到数据库中，而看sql这一句：

"INSERT INTO player(scores,name,password)VALUES("+scores+",'"+newType1+"','"+newType2+"')";

这是数据库插入操作的标准语句，意思为将scores，name，password三个数据插入到player表中，而后执行数据库的更新语句，完成插入。

 

删除：

 

public void deleteData(int mscores){
		String sql="DELETE FROM player WHERE scores="+mscores+"";
		System.out.print(sql);
		try{
			stmt.executeUpdate(sql);
			//System.out.println("一条记录被删除");
		}catch(SQLException e){
			e.printStackTrace();
		}
	}

 

 

"DELETE FROM player WHERE scores="+mscores+"";

 

这句意思为从表里删除所有scores等于mscores的数据，在这里我删除判断条件的只有数据库里的scores是否有等于mscores的，如果还需要加条件，比如要加name判断，则代码如下：

 

public void deleteData(int mscores,String mname){
		String sql="DELETE FROM player WHERE scores="+mscores+"&&name='"+mname+"'";
		System.out.print(sql);
		try{
			stmt.executeUpdate(sql);
			//System.out.println("一条记录被删除");
		}catch(SQLException e){
			e.printStackTrace();
		}
	}

从而语句变为从player表里删除scores等于mscores且name等于mname的所有数据。

修改;

 

 

public void updateData(int mscores,int scores,String name,String password){//修改
		String sql="UPDATE player SET scores="+scores+",name='"+name+"',password='"+password+"'where scores="+mscores+"&&name='"+name+"'&&password='"+password+"'";
		try{
			stmt.executeUpdate(sql);
		}catch(SQLException e){
			e.printStackTrace();
		}
	}

修改了scores的数据。

 

查询：

 

public void  selectPassword(){
		String sql="SELECT scores,name,password FROM player";
		try{
			ResultSet rs=stmt.executeQuery(sql);//返回结果集
			while(rs.next()){//指针向后移动
                         String mpassword=rs.getString("password");
 System.out.print(mpassword);}}catch(Exception e){e.printStackTrace();}}

 

查询操作多了个结果集，来获取每组数据，并用next方法来进行“指针”后移，并用getString方法将password数据读取出来。如果要读取scores的数据。则可修改代码如下：

 

 

String mscores=rs.getShort("scores");

 

 

不同的数据类型从数据库中获取的方法不同。

说完了基本操作，来看看整个的操作类：

package dates;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class DBOperation{
	private MyDBConnection myDB=null;
	private Connection conn=null;
	private Statement stmt=null;
	private int scores;
	private int number1=0;
	private int number2=0;
	private String name;
	private String password;
	public DBOperation(MyDBConnection myDB){
		conn=myDB.getMyConnection();//取得对象
		stmt=myDB.getMyStatement();//取得sql语句
	}
	public void insertData(String name,String password,int scores){
		try{
			String newType1=new String(name.getBytes(),"GBK");//字节转码
			String newType2=new String(password.getBytes(),"GBK");
			String sql="INSERT INTO player(scores,name,password)VALUES("+scores+",'"+newType1+"','"+newType2+"')";
			stmt.executeUpdate(sql);//更新语句
		}catch(Exception e1){
			e1.printStackTrace();
		}
	}
	public void deleteData(int scores){
		String sql="DELETE FROM player WHERE scores="+scores+"";
		System.out.print(sql);
		try{
			stmt.executeUpdate(sql);
			//System.out.println("一条记录被删除");
		}catch(SQLException e){
			e.printStackTrace();
		}
	}
	public void updateData(int mscores,int scores,String name,String password){//修改
		String sql="UPDATE player SET scores="+scores+",name='"+name+"',password='"+password+"'where scores="+mscores+"&&name='"+name+"'&&password='"+password+"'";
		try{
			stmt.executeUpdate(sql);
		}catch(SQLException e){
			e.printStackTrace();
		}
	}
	public boolean  selectPassword(String mpassword){//查询密码
		String sql="SELECT scores,name,password FROM player";
		try{
			ResultSet rs=stmt.executeQuery(sql);//返回结果集
			while(rs.next()){//指针向后移动
				password=rs.getString("password");
				number2++;
				//System.out.print(rs.getString("password")+"  ");
				if(password.equals(mpassword)&&(number2==number1)){
					//System.out.print("number2:"+number2);
					return true;
				}
			}
			
		}catch(Exception e){
			e.printStackTrace();
		}
		return false;
	}
	public boolean selectName(String mname){//查询id
		String sql="SELECT scores,name,password FROM player";
		try{
			ResultSet rs=stmt.executeQuery(sql);//返回结果集
			while(rs.next()){//指针向后移动
				name=rs.getString("name");
				number1++;
				if(name.equals(mname)){
					//System.out.print("number1:"+number1);
					return true;
				}
			}
			
			
		}catch(Exception e){
			e.printStackTrace();
		}
		return false;
	}
	public int getScores(){
		return scores;
	}
	public String getName(){
		return name;
	}
	public String getPassword(){
		return password;
	}
	
	public void setNumber1(){
		number1=0;
	}
	public void setNumber2(){
		number2=0;
	}
}



代码中写了bool类型的selectName与selectPassword方法，并用number1与number2记录name与password在数据库的位置，登录操作实际的思路是在先在数据库中查找用户id，如果查到了就记录此id在第几个位置，并将位置传入selectPassword方法，进行查询密码匹配，判断密码和用户输入的密码是否相同且该密码的位置是否和id的位置相同。如果没找到该id，则提示用户注册，注册其实就是在数据库中插入数据。

下面来看看，一个简单的界面窗口类：

 

 

 

package ui;

import java.awt.Button;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.*;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.*;

import dates.DBOperation;
import dates.MyDBConnection;

public class Window implements MouseListener {

	public JFrame frame = new JFrame("登录窗口");
	private JLabel label1=new JLabel("游戏id:");
	private JTextField txt1=new JTextField();
	private JLabel label2=new JLabel("密   码:");
	private JTextField txt2=new JTextField();
	private JButton btn1=new JButton("登陆");
	private JButton btn2=new JButton("注册");
	private JButton btn3=new JButton("退出");
	private String text1;
	private String text2;
	private int distinguish;//用来记录鼠标悬停在哪个位置
	MyDBConnection myDB=new MyDBConnection();
	public DBOperation myOpr=new DBOperation(myDB);
	public Window(){
	
	}
	
	public void show(){
		frame.setLayout(null);//定义空布局
		frame.setSize(470,300);
		frame.setLocation(400, 200);
		
		Font font=new Font("华文行楷",Font.BOLD,20);
		label1.setFont(font);
		label1.setForeground(Color.gray);//设置字体颜色
		label2.setFont(font);
		
		label2.setForeground(Color.gray);
		txt1.setOpaque(false);//设置文本框透明
		txt2.setOpaque(false);
		
		btn1.setContentAreaFilled(false);//设置button组件透明
		btn1.setFont(font);
	        btn1.setForeground(Color.gray);
	        btn1.setBorder(BorderFactory.createRaisedBevelBorder());//设置突出button组件
	        btn2.setContentAreaFilled(false);
		btn2.setFont(font);
		btn2.setBorder(BorderFactory.createRaisedBevelBorder());
	        btn2.setForeground(Color.gray);
	        btn3.setContentAreaFilled(false);
		btn3.setFont(font);
		btn3.setBorder(BorderFactory.createRaisedBevelBorder());
	        btn3.setForeground(Color.gray);
		JPanel bj = new JPanel() {//设置背景
			protected void paintComponent(Graphics g) {
				Image bg;
				try {
					bg = ImageIO.read(new File("src/image/开始背景.PNG"));
					g.drawImage(bg, 0, 0, getWidth(), getHeight(), null);
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		};
	
	       label1.setBounds(100,50,100,100);
		txt1.setBounds(180,90, 150, 20);
		label2.setBounds(100,80,100,100);
		txt2.setBounds(180,120, 150, 20);
		btn1.setBounds(100,200,80,20);
		btn2.setBounds(190,200,80,20);
		btn3.setBounds(280,200,80,20);
		frame.setContentPane(bj);
		frame.setLayout(null);
		frame.add(label1);
		frame.add(txt1);
		frame.add(label2);
		frame.add(txt2);
		frame.add(btn1);
		frame.add(btn2);
		frame.add(btn3);
		btn1.addMouseListener(this);//添加鼠标监听
		btn2.addMouseListener(this);
		btn3.addMouseListener(this);
		frame.setVisible(true);	
	}
	
	public void mouseClicked(MouseEvent arg0) {
	   text1=txt1.getText();//获取用户输入数据
	   text2=txt2.getText();
	   if(distinguish==1){
	   if(myOpr.selectName(text1)){//登录判断
		   if(myOpr.selectPassword(text2)){
			   JOptionPane.showMessageDialog(null, "登陆成功","提示",2);
				txt1.setText("");
				txt2.setText("");
				distinguish=4;
				frame.setVisible(false);//登录成功则关闭界面
		   }else{
				JOptionPane.showMessageDialog(null, "密码错误","提示",2);
				txt2.setText("");
				myOpr.setNumber1();//密码错误将number置0
				myOpr.setNumber2();
		   }
	   }else{
		   JOptionPane.showMessageDialog(null, "此id不存在，请注册","提示",2);
			txt1.setText("");
			txt2.setText("");
	   }
	   }
	   if(distinguish==2){
		   
		   String logi=(String) JOptionPane.showInputDialog(null,"请输入你的id：\n","注册",JOptionPane.PLAIN_MESSAGE,null,null,"在这输入"); 
		   String pas=(String) JOptionPane.showInputDialog(null,"请输入你的密码：\n","注册",JOptionPane.PLAIN_MESSAGE,null,null,"在这输入");
			myOpr.insertData(logi,pas,0);
			JOptionPane.showMessageDialog(null, "注册成功","提示",2);
	   }
	   if(distinguish==3){
		   int n = JOptionPane.showConfirmDialog(null, "是否退出?", "游戏结束",JOptionPane.YES_NO_OPTION);
		   myDB.closeMyConnection();
			if(n==JOptionPane.YES_OPTION){
			System.exit(1);
			}
	   }
	   
	}

	public void mouseEntered(MouseEvent arg0) {
		if (arg0.getSource() == btn1) {
			distinguish=1;//鼠标悬停在btn1处则把distinguish置1
			btn1.setForeground(Color.red);//改变颜色
			btn1.setBorder(BorderFactory.createLoweredBevelBorder());//组件凹陷
			btn2.setForeground(Color.gray);
			btn2.setBorder(BorderFactory.createRaisedBevelBorder());
			btn3.setForeground(Color.gray);
			btn3.setBorder(BorderFactory.createRaisedBevelBorder());
		}
		if (arg0.getSource() == btn2) {
			distinguish=2;
			btn1.setForeground(Color.gray);
			btn1.setBorder(BorderFactory.createRaisedBevelBorder());
			btn2.setForeground(Color.red);
			btn2.setBorder(BorderFactory.createLoweredBevelBorder());
			btn3.setForeground(Color.gray);
			btn3.setBorder(BorderFactory.createRaisedBevelBorder());
		}
		if (arg0.getSource() == btn3) {
			distinguish=3;
			btn1.setForeground(Color.gray);
			btn1.setBorder(BorderFactory.createRaisedBevelBorder());
			btn2.setForeground(Color.gray);
			btn2.setBorder(BorderFactory.createRaisedBevelBorder());
			btn3.setForeground(Color.red);
			btn3.setBorder(BorderFactory.createLoweredBevelBorder());
			}

	}
	public void mouseExited(MouseEvent arg0) {//鼠标退出三个button组件后恢复
		distinguish=0;
		label1.setForeground(Color.gray);
		label2.setForeground(Color.gray);
		txt1.setOpaque(false);
		txt2.setOpaque(false);
		btn1.setContentAreaFilled(false);
	    btn1.setForeground(Color.gray);
	    btn1.setBorder(BorderFactory.createRaisedBevelBorder());
	    btn2.setContentAreaFilled(false);
		btn2.setBorder(BorderFactory.createRaisedBevelBorder());
	    btn2.setForeground(Color.gray);
	    btn3.setContentAreaFilled(false);
		btn3.setBorder(BorderFactory.createRaisedBevelBorder());
	    btn3.setForeground(Color.gray);
	}
	
	public void mousePressed(MouseEvent arg0) {
			
	}
	public void mouseReleased(MouseEvent arg0) {
		
		
	}
	public String getText1(){
		return text1;
	}
	public String getText2(){
		return text2;
	}
	public int getDistinguish(){
		return distinguish;
	}
	
}



到此为止，所有的登录界面的介绍已完成，下面是登录的背景材料和完整的代码。

 

 

 



代码链接：https://pan.baidu.com/s/1_AFdIFe01WKSUa0lEPD3-Q

 

具体的代码在这个练手的项目里:...，https://github.com/suyeq/java-fly-fight，一个飞机大战小项目

 

 

 

1.新建一个Web Project项目,命名为：test;
2.在项目test中的src文件中，新建三个包，分别为：entity(实体)包、dao包、DBHelper包；
3.在entity中，新建一个Class,在文件中编写user的属性，并添加get和set方法，例如下图：
 
4.以下为DBHepler文件中的内容：

  1 package DBHelper;
  2 
  3 import java.io.Console;
  4 import java.sql.*;
  5 import java.util.Enumeration;
  6 //import java.util.logging.*;
  7 //import javax.swing.table.*;
  8 
  9 /**
 10  * SQL 基本操作 通过它,可以很轻松的使用 JDBC 来操纵数据库
 11  * 
 12  * @author Null
 13  */
 14 public class DBHelper {
 15 
 16     /**
 17      * 驱动
 18      */
 19     // public static String driver =
 20     // "com.microsoft.jdbc.sqlserver.SQLServerDriver";
 21     public static String driver = "com.mysql.jdbc.Driver";
 22     /**
 23      * 连接字符串
 24      */
 25     // public static String url =
 26     // "jdbc:microsoft:sqlserver://127.0.0.1:1433;DatabaseName=st";
 27     public static String url = "jdbc:mysql://localhost:3306/loginuser";
 28     /**
 29      * 用户名
 30      */
 31     public static String user = "root";
 32     /**
 33      * 密码
 34      */
 35     public static String password = "sjl37";
 36 
 37     /**
 38      * 不允许实例化该类
 39      */
 40     private DBHelper() {
 41     }
 42 
 43     /**
 44      * 获取一个数据库连接 通过设置类的 driver / url / user / password 这四个静态变量来 设置数据库连接属性
 45      * 
 46      * @return 数据库连接
 47      */
 48     public static Connection getConnection() {
 49         try {
 50             // 获取驱动
 51             Class.forName(driver);
 52         } catch (ClassNotFoundException ex) {
 53             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
 54             // null, ex);
 55             System.out.println(ex.getMessage());
 56         }
 57 
 58         try {
 59             return DriverManager.getConnection(url, user, password);
 60         } catch (SQLException ex) {
 61             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
 62             // null, ex);
 63             System.out.println(ex.getMessage());
 64             return null;
 65         }
 66     }
 67 
 68     /**
 69      * 获取一个 Statement 该 Statement 已经设置数据集 可以滚动,可以更新
 70      * 
 71      * @return 如果获取失败将返回 null,调用时记得检查返回值
 72      */
 73     public static Statement getStatement() {
 74         Connection conn = getConnection();
 75         if (conn == null) {
 76             return null;
 77         }
 78         try {
 79             return conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
 80                     ResultSet.CONCUR_UPDATABLE);
 81             // 鐠佸墽鐤嗛弫鐗堝祦闂嗗棗褰叉禒銉︾泊閸旓拷閸欘垯浜掗弴瀛樻煀
 82         } catch (SQLException ex) {
 83             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
 84             // null, ex);
 85             System.out.println(ex.getMessage());
 86             close(conn);
 87         }
 88         return null;
 89     }
 90 
 91     /**
 92      * 获取一个 Statement 该 Statement 已经设置数据集 可以滚动,可以更新
 93      * 
 94      * @param conn
 95      *            数据库连接
 96      * @return 如果获取失败将返回 null,调用时记得检查返回值
 97      */
 98     public static Statement getStatement(Connection conn) {
 99         if (conn == null) {
100             return null;
101         }
102         try {
103 
104             return conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
105                     ResultSet.CONCUR_UPDATABLE);
106             // 设置数据集可以滚动,可以更新
107         } catch (SQLException ex) {
108             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
109             // null, ex);
110             System.out.println(ex.getMessage());
111             return null;
112         }
113     }
114 
115     /**
116      * 获取一个带参数的 PreparedStatement 该 PreparedStatement 已经设置数据集 可以滚动,可以更新
117      * 
118      * @param cmdText
119      *            需要 ? 参数的 SQL 语句
120      * @param cmdParams
121      *            SQL 语句的参数表
122      * @return 如果获取失败将返回 null,调用时记得检查返回值
123      */
124     public static PreparedStatement getPreparedStatement(String cmdText,
125             Object[] cmdParams) {
126         Connection conn = getConnection();
127         if (conn == null) {
128             return null;
129         }
130 
131         PreparedStatement pstmt = null;
132         try {
133 
134             pstmt = conn
135                     .prepareStatement(cmdText, ResultSet.TYPE_SCROLL_SENSITIVE,
136                             ResultSet.CONCUR_UPDATABLE);
137             int i = 1;
138             for (Object item : cmdParams) // java
139                                             // foreach遍历集合,要求集合类实现Enumeration接口
140             {
141                 pstmt.setObject(i, item);
142                 i++;
143             }
144         } catch (SQLException e) {
145             e.printStackTrace();
146             close(conn);
147         }
148         return pstmt;
149     }
150 
151     /**
152      * 获取一个带参数的 PreparedStatement 该 PreparedStatement 已经设置数据集 可以滚动,可以更新
153      * 
154      * @param conn
155      *            数据库连接
156      * @param cmdText
157      *            需要 ? 参数的 SQL 语句
158      * @param cmdParams
159      *            SQL 语句的参数表
160      * @return 如果获取失败将返回 null,调用时记得检查返回值
161      */
162     public static PreparedStatement getPreparedStatement(Connection conn,
163             String cmdText, Object[] cmdParams) {
164         if (conn == null) {
165             return null;
166         }
167 
168         PreparedStatement pstmt = null;
169         try {
170             pstmt = conn
171                     .prepareStatement(cmdText, ResultSet.TYPE_SCROLL_SENSITIVE,
172                             ResultSet.CONCUR_UPDATABLE);
173             int i = 1;
174             for (Object item : cmdParams) {
175                 pstmt.setObject(i, item);
176                 i++;
177             }
178         } catch (SQLException ex) {
179             System.out.println(ex.getMessage());
180             // ex.printStackTrace();
181             close(pstmt);
182         }
183         return pstmt;
184     }
185 
186     /**
187      * 执行 SQL 语句,返回结果为整型 主要用于执行非查询语句
188      * 
189      * @param cmdText
190      *            SQL 语句
191      * @return 非负数:正常执行; -1:执行错误; -2:连接错误
192      */
193     public static int ExecSql(String cmdText) {
194         Statement stmt = getStatement();
195         if (stmt == null) {
196             return -2;
197         }
198         int i;
199         try {
200             i = stmt.executeUpdate(cmdText);
201         } catch (SQLException ex) {
202             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
203             // null,ex);
204             System.out.println(ex.getMessage());
205             i = -1;
206         }
207         closeConnection(stmt);
208         return i;
209     }
210 
211     /**
212      * 执行 SQL 语句,返回结果为整型 主要用于执行非查询语句
213      * 
214      * @param cmdText
215      *            SQL 语句
216      * @return 非负数:正常执行; -1:执行错误; -2:连接错误
217      */
218     public static int ExecSql(Connection conn, String cmdText) {
219         Statement stmt = getStatement(conn);
220         if (stmt == null) {
221             return -2;
222         }
223         int i;
224         try {
225             i = stmt.executeUpdate(cmdText);
226 
227         } catch (SQLException ex) {
228             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
229             // null, ex);
230             System.out.println(ex.getMessage());
231 
232             i = -1;
233         }
234         close(stmt);
235         return i;
236     }
237 
238     /**
239      * 执行 SQL 语句,返回结果为整型 主要用于执行非查询语句
240      * 
241      * @param cmdText
242      *            需要 ? 参数的 SQL 语句
243      * @param cmdParams
244      *            SQL 语句的参数表
245      * @return 非负数:正常执行; -1:执行错误; -2:连接错误
246      */
247     public static int ExecSql(String cmdText, Object[] cmdParams) {
248         PreparedStatement pstmt = getPreparedStatement(cmdText, cmdParams);
249         if (pstmt == null) {
250             return -2;
251         }
252         int i;
253         try {
254             i = pstmt.executeUpdate();
255         } catch (SQLException ex) {
256             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
257             // null, ex);
258             System.out.println(ex.getMessage());
259             i = -1;
260         }
261         closeConnection(pstmt);
262         return i;
263     }
264 
265     /**
266      * 执行 SQL 语句,返回结果为整型 主要用于执行非查询语句
267      * 
268      * @param conn
269      *            数据库连接
270      * @param cmdText
271      *            需要 ? 参数的 SQL 语句
272      * @param cmdParams
273      *            SQL 语句的参数表
274      * @return 非负数:正常执行; -1:执行错误; -2:连接错误
275      */
276     public static int ExecSql(Connection conn, String cmdText,
277             Object[] cmdParams) {
278         PreparedStatement pstmt = getPreparedStatement(conn, cmdText, cmdParams);
279         if (pstmt == null) {
280             return -2;
281         }
282         int i;
283         try {
284             i = pstmt.executeUpdate();
285 
286         } catch (SQLException ex) {
287             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
288             // null, ex);
289             System.out.println(ex.getMessage());
290             i = -1;
291         }
292         close(pstmt);
293         return i;
294     }
295 
296     /**
297      * 返回结果集的第一行的一列的值,其他忽略
298      * 
299      * @param cmdText
300      *            SQL 语句
301      * @return
302      */
303     public static Object ExecScalar(String cmdText) {
304         ResultSet rs = getResultSet(cmdText);
305         Object obj = getScalar(rs);
306         closeConnection(rs);
307         return obj;
308     }
309 
310     /**
311      * 返回结果集的第一行的一列的值,其他忽略
312      * 
313      * @param conn
314      *            数据库连接
315      * @param cmdText
316      *            SQL 语句
317      * @return
318      */
319     public static Object ExecScalar(Connection conn, String cmdText) {
320         ResultSet rs = getResultSet(conn, cmdText);
321         Object obj = getScalar(rs);
322         closeEx(rs);
323         return obj;
324     }
325 
326     /**
327      * 返回结果集的第一行的一列的值,其他忽略
328      * 
329      * @param cmdText
330      *            需要 ? 参数的 SQL 语句
331      * @param cmdParams
332      *            SQL 语句的参数表
333      * @return
334      */
335     public static Object ExecScalar(String cmdText, Object[] cmdParams) {
336         ResultSet rs = getResultSet(cmdText, cmdParams);
337         Object obj = getScalar(rs);
338         closeConnection(rs);
339         return obj;
340     }
341 
342     /**
343      * 返回结果集的第一行的一列的值,其他忽略
344      * 
345      * @param conn
346      *            数据库连接
347      * @param cmdText
348      *            需要 ? 参数的 SQL 语句
349      * @param cmdParams
350      *            SQL 语句的参数表
351      * @return
352      */
353     public static Object ExecScalar(Connection conn, String cmdText,
354             Object[] cmdParams) {
355         ResultSet rs = getResultSet(conn, cmdText, cmdParams);
356         Object obj = getScalar(rs);
357         closeEx(rs);
358         return obj;
359     }
360 
361     /**
362      * 返回一个 ResultSet
363      * 
364      * @param cmdText
365      *            SQL 语句
366      * @return
367      */
368     public static ResultSet getResultSet(String cmdText) {
369         Statement stmt = getStatement();
370         if (stmt == null) {
371             return null;
372         }
373         try {
374             return stmt.executeQuery(cmdText);
375         } catch (SQLException ex) {
376             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
377             // null, ex);
378             System.out.println(ex.getMessage());
379             closeConnection(stmt);
380         }
381         return null;
382     }
383 
384     /**
385      * 返回一个 ResultSet
386      * 
387      * @param conn
388      * @param cmdText
389      *            SQL 语句
390      * @return
391      */
392     public static ResultSet getResultSet(Connection conn, String cmdText) {
393         Statement stmt = getStatement(conn);
394         if (stmt == null) {
395             return null;
396         }
397         try {
398             return stmt.executeQuery(cmdText);
399         } catch (SQLException ex) {
400             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
401             // null, ex);
402             System.out.println(ex.getMessage());
403             close(stmt);
404         }
405         return null;
406     }
407 
408     /**
409      * 返回一个 ResultSet
410      * 
411      * @param cmdText
412      *            需要 ? 参数的 SQL 语句
413      * @param cmdParams
414      *            SQL 语句的参数表
415      * @return
416      */
417     public static ResultSet getResultSet(String cmdText, Object[] cmdParams) {
418         PreparedStatement pstmt = getPreparedStatement(cmdText, cmdParams);
419         if (pstmt == null) {
420             return null;
421         }
422         try {
423             return pstmt.executeQuery();
424         } catch (SQLException ex) {
425             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
426             // null, ex);
427             System.out.println(ex.getMessage());
428             closeConnection(pstmt);
429         }
430         return null;
431     }
432 
433     /**
434      * 返回一个 ResultSet
435      * 
436      * @param conn
437      *            数据库连接
438      * @param cmdText
439      *            需要 ? 参数的 SQL 语句
440      * @param cmdParams
441      *            SQL 语句的参数表
442      * @return
443      */
444     public static ResultSet getResultSet(Connection conn, String cmdText,
445             Object[] cmdParams) {
446         PreparedStatement pstmt = getPreparedStatement(conn, cmdText, cmdParams);
447         if (pstmt == null) {
448             return null;
449         }
450         try {
451             return pstmt.executeQuery();
452         } catch (SQLException ex) {
453             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
454             // null, ex);
455             System.out.println(ex.getMessage());
456             close(pstmt);
457         }
458         return null;
459     }
460 
461     public static Object getScalar(ResultSet rs) {
462         if (rs == null) {
463             return null;
464         }
465         Object obj = null;
466         try {
467             if (rs.next()) {
468                 obj = rs.getObject(1);
469             }
470         } catch (SQLException ex) {
471             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
472             // null, ex);
473             System.out.println(ex.getMessage());
474         }
475         return obj;
476     }
477 
478     private static void close(Object obj) {
479         if (obj == null) {
480             return;
481         }
482         try {
483             if (obj instanceof Statement) {
484                 ((Statement) obj).close();
485             } else if (obj instanceof PreparedStatement) {
486                 ((PreparedStatement) obj).close();
487             } else if (obj instanceof ResultSet) {
488                 ((ResultSet) obj).close();
489             } else if (obj instanceof Connection) {
490                 ((Connection) obj).close();
491             }
492         } catch (SQLException ex) {
493             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
494             // null, ex);
495             System.out.println(ex.getMessage());
496         }
497     }
498 
499     private static void closeEx(Object obj) {
500         if (obj == null) {
501             return;
502         }
503 
504         try {
505             if (obj instanceof Statement) {
506                 ((Statement) obj).close();
507             } else if (obj instanceof PreparedStatement) {
508                 ((PreparedStatement) obj).close();
509             } else if (obj instanceof ResultSet) {
510                 ((ResultSet) obj).getStatement().close();
511             } else if (obj instanceof Connection) {
512                 ((Connection) obj).close();
513             }
514         } catch (SQLException ex) {
515             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
516             // null, ex);
517             System.out.println(ex.getMessage());
518         }
519 
520     }
521 
522     private static void closeConnection(Object obj) {
523         if (obj == null) {
524             return;
525         }
526         try {
527             if (obj instanceof Statement) {
528                 ((Statement) obj).getConnection().close();
529             } else if (obj instanceof PreparedStatement) {
530                 ((PreparedStatement) obj).getConnection().close();
531             } else if (obj instanceof ResultSet) {
532                 ((ResultSet) obj).getStatement().getConnection().close();
533             } else if (obj instanceof Connection) {
534                 ((Connection) obj).close();
535             }
536         } catch (SQLException ex) {
537             // Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
538             // null, ex);
539             System.out.println(ex.getMessage());
540         }
541     }
542 }

DBHelper的全部代码
5.将mysql连接数据库的jar包，添加到WebRoot---->WEB-INF---->lib中；
6.在DAO包中，添加一个Class文件，编辑User的操作方法,例如以下代码：

 1 package dao;
 2     import entity.*;
 3     import DBHelper.*;
 4     public class userDao {
 5         public static boolean add(User u)
 6         {
 7             String sql="INSERT INTO User(userID,userName) "+
 8                        "VALUES(?,?)";
 9             Object[] params=new Object[]{u.getUserID(),u.getUserName()};;  
10             DBHelper.ExecSql(sql, params);
11             return true;
12         }
13         
14         public static boolean delete(User u)
15         {
16             String sql="DELETE FROM User WHERE userID=?";
17             Object[] params=new Object[]{u.getUserID()};
18             DBHelper.ExecSql(sql, params);
19             return true;
20         }
21         
22         public static boolean update(User u)
23         {
24             return true;
25         }
26     }

userDAO的部分方法代码
 7.在WebRoot中，新建一个login.jsp:

 1 <%@page import="DBHelper.DBHelper"%>
 2 <%@page import="java.sql.ResultSet"%>
 3 <%@page import="java.sql.PreparedStatement"%>
 4 <%@page import="java.sql.DriverManager"%>
 5 <%@page import="java.sql.Connection"%>
 6 <%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
 7 <%
 8 String path = request.getContextPath();
 9 String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
10 %>
11 
12 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
13 <html>
14 <head>
15 <base href="<%=basePath%>">
16 
17 <title>这是我的登录界面</title>
18 
19 <meta http-equiv="pragma" content="no-cache">
20 <meta http-equiv="cache-control" content="no-cache">
21 <meta http-equiv="expires" content="0">
22 <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
23 <meta http-equiv="description" content="This is my page">
24 <!--
25     <link rel="stylesheet" type="text/css" href="styles.css">
26     -->
27 
28 </head>
29 
30 <body>
31     <%
32      String SQL="SELECT * FROM user WHERE userName=? AND password=?";
33      String uid=request.getParameter("uid");
34      String pwd=request.getParameter("pwd");
35     Object[] params=new Object[]{uid,pwd};
36     ResultSet rs=DBHelper.getResultSet(SQL, params);
37      if(rs.next())
38        out.println("登陆成功！");
39      else
40        out.println("登陆失败！");
41      rs.close(); 
42     %>
43 </body>
44 </html>

login.jsp页面代码
8.在index.jsp中，连接login.jsp页面，并简单地设计登录的界面：

1 <body>
2     <form name="f1" action="login/login.jsp">
3         账户：<input type="text" name="uid"><br>
4         密码：<input type="password" name="pwd"><br>
5         <input type="submit" value="登录">
6     </form>
7   </body>

login的登录界面
 
 
数据库中的表格内容：

 
 
转载于:https://www.cnblogs.com/shaojiangli-11437/p/5261903.html

一：首先在eclipse中新建一个java工程

二：然后新建一个包，并且在包中新建两个类：一个事登录用的界面(Login)类，一个事连接数据库的（jdbcs）类我建立的是p4这个包

三：导入包mysql-connector-java-8.0.16.jar并且要添加到构建路径不添加到构建路径项目工程不会读出来的

(原先的驱动com.mysql.jdbc.Driver已经升级到了com.mysql.cj.jdbc.Driver)

maven项目可以加入

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.16</version>
</dependency>


四：编写那个界面Login类

那个界面类的源代码如下：

 

import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.*;

/**
 * @author yh128
 * @version 1.0.0
 * @ClassName Login.java
 * @Description 登录类
 * @Param
 * @createTime 2019年06月11日 11:27:00
 */
public class Login extends JFrame implements ActionListener {
    private JPanel pan = new JPanel();
    private JLabel namelab = new JLabel("用户名");
    private JLabel passlab = new JLabel("密    码");
    private JTextField nametext = new JTextField();
    private JPasswordField passtext = new JPasswordField();


    public JButton denglu = new JButton("登录");
    public JButton zhuce = new JButton("注册");
    public JButton updatepass = new JButton("修改密码");
    public JButton deleteuser = new JButton("删除用户");


    public Login() {
        Font font = new Font("宋体", Font.BOLD, 12);
        super.setTitle("欢迎登录本系统");
        pan.setLayout(null);
        namelab.setBounds(20, 20, 60, 30);
        nametext.setBounds(90, 20, 140, 30);
        passlab.setBounds(20, 60, 60, 30);
        passtext.setBounds(90, 60, 140, 30);
        denglu.setBounds(30, 120, 90, 20);
        zhuce.setBounds(140, 120, 90, 20);
        updatepass.setBounds(30, 150, 90, 20);
        deleteuser.setBounds(140, 150, 90, 20);

        pan.add(namelab);
        pan.add(nametext);
        pan.add(passlab);
        pan.add(passtext);
        pan.add(denglu);
        pan.add(zhuce);
        pan.add(updatepass);
        pan.add(deleteuser);

        passtext.setFont(font);
        zhuce.setFont(font);
        updatepass.setFont(font);
        deleteuser.setFont(font);

        denglu.addActionListener(this);
        zhuce.addActionListener(this);
        updatepass.addActionListener(this);
        deleteuser.addActionListener(this);

        super.add(pan);
        super.setSize(300, 250);
        super.setVisible(true);
    }

    public static void main(String[] args) {

        new Login();
    }

    @Override
    public void actionPerformed(ActionEvent arg0) {
        if (arg0.getSource() == denglu) {
            denglu();
        } else if (arg0.getSource() == zhuce) {
            zhuce();
        } else if (arg0.getSource() == updatepass) {
            updatepass();
        } else if (arg0.getSource() == deleteuser) {
            deleteuser();
        }

    }

    //登录按钮的事件处理函数
    public void denglu() {
        Jdbcs d = new Jdbcs();
        String username = nametext.getText();
        String password = passtext.getText();
        if (d.compare(username, password)) {
            JOptionPane.showMessageDialog(null, "登录成功！");
            super.setVisible(false);
        }
    }

    //注册按钮触发后的事件处理函数
    public void zhuce() {
        Jdbcs d = new Jdbcs();
        String username = nametext.getText();
        String password = passtext.getText();
        d.insert(username, password);
    }

    //修改密码按钮触发后的事件处理函数
    public void updatepass() {
        pan.setEnabled(false);
        JFrame frame1 = new JFrame("密码修改");
        frame1.setSize(250, 200);
        JPanel updatepass = new JPanel();
        JLabel namelab1 = new JLabel("用户名");
        JLabel passlab1 = new JLabel("旧密码");
        JLabel newpasslab = new JLabel("新密码");
        JTextField nametext1 = new JTextField("" + nametext.getText());
        JPasswordField passtext1 = new JPasswordField();
        JPasswordField newpasstext = new JPasswordField();
        JButton ok = new JButton("修改");
        JButton resert = new JButton("重置");

        updatepass.setLayout(null);

        namelab1.setBounds(5, 5, 70, 20);
        nametext1.setBounds(80, 5, 120, 20);
        passlab1.setBounds(5, 30, 70, 20);
        passtext1.setBounds(80, 30, 120, 20);
        newpasslab.setBounds(5, 60, 70, 20);
        newpasstext.setBounds(80, 60, 120, 20);
        ok.setBounds(10, 110, 60, 20);
        resert.setBounds(90, 110, 60, 20);

        updatepass.add(namelab1);
        updatepass.add(nametext1);
        updatepass.add(passlab1);
        updatepass.add(passtext1);
        updatepass.add(newpasslab);
        updatepass.add(newpasstext);
        updatepass.add(ok);
        updatepass.add(resert);

        frame1.add(updatepass);
        frame1.setVisible(true);

        ok.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent arg0) {
                Jdbcs d = new Jdbcs();
                String username = nametext1.getText();
                String password1 = passtext1.getText();
                String newpassword = newpasstext.getText();
                if (d.update(username, password1, newpassword)) {
                    frame1.setVisible(false);
                }
            }
        });
        //重置文本框 里的内容
        resert.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent arg0) {

                nametext1.setText("");
                passtext1.setText("");
                newpasstext.setText("");
            }
        });
    }

    //删除用户按钮触发后的事件处理函数
    public void deleteuser() {
        String username = nametext.getText();
        String password = passtext.getText();
        Jdbcs s = new Jdbcs();
        s.delete(username, password);
    }

}



 

 

五：写连接数据库的代码以及用到的操作的源代码

jdbcs这个类的源代码如下：

 

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/**
 * @author yh128
 * @version 1.0.0
 * @ClassName Jdbcs.java
 * @Description 数据库连接类
 * @Param
 * @createTime 2019年06月11日 11:28:00
 */

import javax.swing.JOptionPane;

public class Jdbcs {
    Connection con = null;
    Statement statement = null;
    ResultSet res = null;
    String driver = "com.mysql.cj.jdbc.Driver";
    String url = "jdbc:mysql://localhost:3306/user?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai";
    String name = "root";
    String passwd = "123456";

    public Jdbcs() {
        try {
            Class.forName(driver).newInstance();
            con = DriverManager.getConnection(url, name, passwd);
            statement = con.createStatement();

        } catch (ClassNotFoundException e) {
            System.out.println("对不起，找不到这个Driver");
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //对用户信息的修改实际上就是对密码的修改
    public boolean update(String username1, String password1, String newpassword) {
        boolean judge = false;
        boolean s = compare(username1, password1);
        if (s) {
            String sql = "update user set password=\"" + newpassword + "\"where username=\"" + username1 + "\"";
            try {
                int a = statement.executeUpdate(sql);
                if (a == 1) {
                    JOptionPane.showMessageDialog(null, "密码修改成功！");
                    judge = true;
                }
                con.close();
                statement.close();
            } catch (SQLException e) {
                JOptionPane.showMessageDialog(null, "用户不存在！");
                e.printStackTrace();
            }
        } else {
            JOptionPane.showMessageDialog(null, "修改失败");
        }
        return judge;
    }

    //删除用户信息
    public void delete(String username, String password) {
        if (compare(username, password)) {
            JOptionPane.showMessageDialog(null, "已经完成删除");
        } else {
            return;
        }
        String sql = "delete from user where username=\"" + username + "\"";
        try {
            int a = statement.executeUpdate(sql);
            con.close();
            statement.close();
        } catch (SQLException e) {
            JOptionPane.showMessageDialog(null, "不存在该用户！");
            e.printStackTrace();
        }

    }

    //用户注册功能的实现，添加数据
    public void insert(String username, String password) {
        if (username == null || username.trim().length() <= 0) {
            JOptionPane.showMessageDialog(null, "注册账号为空，请重新输入！");
            return;
        }
        String sql = "insert into user(username,password) values(\"" + username + "\",\"" + password + "\")";
        try {
            int a = statement.executeUpdate(sql);
            con.close();
            statement.close();
            if (a == 1) {
                JOptionPane.showMessageDialog(null, "注册成功！");
            }
        } catch (SQLException e) {
            JOptionPane.showMessageDialog(null, "对不起该用户名已经有了！");
            e.printStackTrace();
        }
    }

    //对比用户名和密码是不匹配
    public boolean compare(String username, String password) {
        boolean m = false;
        String sql = "select password from user where username=\"" + username + "\"";
        try {
            res = statement.executeQuery(sql);
            if (res.next()) {
                String pa = res.getString(1);
                System.out.println(pa + " " + password);
                if (pa.equals(password)) {
                    m = true;
                } else {
                    JOptionPane.showMessageDialog(null, "密码错误！");
                }
            } else {
                JOptionPane.showMessageDialog(null, "用户名不存在！");
            }
            res.close();
            con.close();
            statement.close();

        } catch (SQLException e) {
            e.printStackTrace();
        }
        return m;
    }

}




六：代码写完了 但是数据库还没有建立吧，那就建立数据库吧

先建立一个数据库

用到命令是

create database user;

然后新建一个表：

use user;

create table user(username varchar(20) primary key, password varchar(20));

现在表是空的，往表中添加几个数据：

insert into user(username,password) values("A",“123456”）,("B","asdfg");

 



 





 



 



 



 

本文主要向大家介绍了java连接MySQL数据库简单实现 ，通过具体的内容向大家展现，希望对大家学习MySQL数据库有所帮助。
<
因为最近要做一个涉及到数据库的具体应用，选择数据库mysql，用java连接mysql做一个学生信息管理系统的简单版本。
工具：eclipse，jdbc，mysql
如上一篇中，mysql为免安装版本，没有装可视化，所以使用命令行对数据库执行操作。
1.登录
进入相关目录后输入指令进行登录
mysql -u root -p
技术分享图片
登录后可以查看现有数据库：show databases；
技术分享图片
2.新建数据库
新建一个数据库studentbase，并查看。
create database studentbase；
show databases；
可以看到新创建的数据库已经显示在列表中。
技术分享图片
3.在新数据库中创建表
创建数据库后不会立刻使用它，所以需要选择使用该数据库：
use studentbase；
数据库只需要创建一次，但是每次开始mysql时都要选择数据库，当然也可以有简单的方法，在登录时就选择了数据库。如：
shell> mysql -h host -u user -p studentbase
Enter password: ********
选择好数据库后，开始在库中创建表，我们可以先看看库中有什么。语句：
mysql> SHOW TABLES;
Empty set (0.00 sec)
可以看到库中一无所有，所以可以新建一张表用来存放学生信息，如学号，姓名，性别，地址和生日五个基本信息。在官方手册中给出的创建表的实例为：
mysql> CREATE TABLE pet (name VARCHAR(20), owner VARCHAR(20),
-> species VARCHAR(20), sex CHAR(1), birth DATE, death DATE);
而我们的创建过程为：
技术分享图片
注意输入时如果输错可以选择撤销输入： \c
在创建后我想看下创建的表的视图，输入指令：describe students; 却发现提示错误说该表为找到，检查发现原来创建表时候打错了表的名字，将表明修改后即可查询到。
修改表名：alter table sutdents rename students;
技术分享图片
再查看视图，则可以看到设计好的表的视图如下：
技术分享图片
一些基本的sql语句：
数据库：
进入mysql 命令行: mysql -uroot -p
查看所有数据库: show databases;
创建数据库： create database niu charset utf8;
删除数据库： drop database niu;
选择数据库： use databases;
查看所有表： show tables;
查看创建数据库的语句：show create database databasename;
查看创建表的语句：show create table tablename;
查看表结构：desc tablenmae;
表：
约束
#自增长 auto_increment
#非空 not null
#默认值 default ‘xx‘
#唯一 unique
#指定字符集 charset
#主键 primary key
本文由职坐标整理并发布，希望对同学们学习MySQL有所帮助，更多内容请关注职坐标数据库MySQL数据库频道！