Duas maneiras de estabelecer a conexão do banco de dados usando o JDBC:
1. Use DriverManager no código para obter a conexão do banco de dados. Esse método é ineficiente e seu desempenho, confiabilidade e estabilidade diminuem gradualmente à medida que o número de visitas aos usuários aumenta.
2. Use o método de configurar fontes de dados para conectar -se ao banco de dados. A essência deste método é adicionar um pool de conexão de banco de dados com base no método acima, que é altamente eficiente.
Há a seguinte diferença entre conectar -se a um banco de dados usando o DriverManager no código:
1) O pool de conexão de fonte de dados é conectado ao banco de dados no programa. Ao consultar um servidor JNDI (Java Naming and Directory Interface), ou seja, chamando o método Lookup () da interface de contexto para obter o objeto DataSource e, em seguida, chamando o método getConnection () do objeto DataSource para estabelecer uma conexão.
2) Para reutilizar objetos de conexão com o banco de dados, melhore o tempo de resposta às solicitações e o desempenho do servidor, a tecnologia de pool de conexões é adotada. A tecnologia de pool de conexões estabelece vários objetos de conexão de banco de dados com antecedência e salva o objeto de conexão no pool de conexão. Quando a solicitação do cliente ocorre, um objeto de conexão é retirado do pool para servir o cliente. Quando a solicitação é concluída, o programa do cliente chama o método Close () e coloca o objeto de conexão de volta no pool.
3) No caminho do uso do DriverManager para obter conexões de banco de dados no código, o objeto de conexão obtido pelo programa do cliente é uma conexão física. Chamar o método Close () do objeto de conexão fechará a conexão. Usando a tecnologia de pool de conexão, o objeto de conexão obtido pelo programa do cliente é um identificador para a conexão física no pool de conexões. Chamando o método Close () do objeto de conexão, a conexão física não está fechada. A implementação da fonte de dados exclui apenas a conexão entre o objeto de conexão no programa do cliente e o objeto de conexão no pool.
Para testar a conveniência, você pode criar uma tabela de usuários no banco de dados (consulte MySQL 5 como exemplo aqui):
Criar tabela `user` (` id` int (10) não assinado NÃO NULL AUTO_INCREMENT, `Nome de usuário` Varchar (50) NULL padrão,` senha` varchar (50) nulo padrão, `email` Varchar (50) NULL, chave primária (` id`),);
Importe o pacote JAR do driver do banco de dados no diretório Lib do tomcat (aqui, tomando o MySQL5 como exemplo, o pacote JAR usado é: MySQL-Connector-Java-5.0.8-bin.jar).
1. Use DriverManager no código para obter a conexão do banco de dados. Esse método é ineficiente e seu desempenho, confiabilidade e estabilidade diminuem gradualmente à medida que o número de visitas aos usuários aumenta.
O código Java para a conexão do banco de dados Oracle é o seguinte:
importar java.sql.connection; importar java.SQL.DriverManager; / ***Obtenha conexão com o banco de dados*/ public class DBConnection {/ ** Oracle Database Connection URL*/ String estática final privada db_url = "JDBC: Oracle: Thin:@127.0.0.1: 1521: orcl"; / ** Driver de conexão do banco de dados Oracle*/ String estática final privada db_driver = "oracle.jdbc.driver.oracledriver"; / ** nome de usuário do banco de dados*/ string estática final privada db_username = "root"; / ** Senha do banco de dados*/ String estática final privada db_password = "admin"; / *** Obtenha conexão com o banco de dados* @return*/ public conexão getConnection () {/ ** Declare o objeto de conexão de conexão*/ conexão conn = null; tente { / ** use o método Class.ForName () para criar automaticamente uma instância desse driver e ligue para o DriverManager automaticamente para registrá -lo* / Class.ForName (db_driver); / ** Obtenha conexão do banco de dados através do método driverManager getConnection () } catch (Exceção ex) {ex.PrintStackTrace (); } retornar Conn; } / *** Feche a conexão do banco de dados** @param connect* / public void ClosConnection (conexão conn) {try {if (conn! = Null) { / ** Determine que o objeto de conexão atual não está fechado, ligue para o método de fechamento* / if (! Conn.iscosed ()) {Conn.Close (); }}} catch (Exceção ex) {ex.printStackTrace (); }}}O código JSP para a conexão do banco de dados MySQL é o seguinte:
<%@página import = "java.sql. Class.ForName (driver.class.getName ()). NewInstance (); String url = "jdbc: mysql: // localhost: 3306/Demo? UseUnicode = true & caracterEncoding = utf8"; String user = "root"; String senha = "123"; Conexão conn = driverManager.getConnection (URL, usuário, senha); Instrução stmt = conn.createstatement (); String sql = "selecione * do usuário"; ResultSet rs = stmt.executeQuery (SQL); while (rs.Next ()) {out.print ("<r />" + "=====================" + "<r />"); out.print (rs.getlong ("id") + ""); out.print (rs.getString ("nome de usuário") + ""); out.print (rs.getString ("senha") + ""); out.print (rs.getString ("email") + ""); } %> </body> </html>2. Use o método de configurar fontes de dados para conectar -se ao banco de dados. A essência deste método é adicionar um pool de conexão de banco de dados com base no método acima, que é altamente eficiente.
1) O código JSP do pool de conexão de origem de dados do banco de dados MySQL é o seguinte:
<%@página import = "java.sql.*, javax.naming. DataSource DS = (DataSource) initctx.lookup ("java: comp/Env/jdbc/demodb"); Conexão conn = ds.getConnection (); Instrução stmt = conn.createstatement (); String sql = "selecione * do usuário"; ResultSet rs = stmt.executeQuery (SQL); while (rs.Next ()) {out.print ("<r />" + "=====================" + "<r />"); out.print (rs.getlong ("id") + ""); out.print (rs.getString ("nome de usuário") + ""); out.print (rs.getString ("senha") + ""); out.print (rs.getString ("email") + ""); } %> </body> </html>2) Adicione o seguinte código ao server.xml no diretório confiado do tomcat:
<Context> <Resource name="jdbc/demoDB" auth="Container" type="javax.sql.DataSource" driverClassName="com.mysql.jdbc.Driver" url="jdbc:mysql://localhost:3306/demo" username="root" password="123" maxActive="50" maxIdle="30" maxwait = "10000" /> </xectent>
3) Configure o seguinte conteúdo no nó raiz do web.xml no diretório do projeto da web:
<Source-ref> <cription> conexão mysqldb </cription> <s-ref-name> jdbc/demodb </s-ref-name> <Res-Type> javax.sql.datasource </restype> <s Respice>
A configuração do pool de conexão da fonte de dados foi concluída, mas, para melhorar a portabilidade do projeto, é melhor colocar o conteúdo do segundo passo acima no contexto.xml do diretório meta-inf do projeto (esse arquivo precisa ser criado por si só):
<? xml versão = "1.0" coding = "utf-8"?> <Context> <nome do recurso = "jdbc/demodb" auth = "container" type = "javax.sql.dataSource" driverclassName = "com.mysql.jdbc.driver" url = jdbcc: " nome de usuário = "root" senha = "123" maxactive = "50" maxidle = "30" maxwait = "10000" /> < /context>
3. Classe de ferramenta de operação do banco de dados ao configurar o pool de conexão do banco de dados da fonte de dados
O código é o seguinte:
pacote db.utils; importar java.sql.connection; importar java.SQL.PreparedStatement; importar java.sql.resultset; importar java.sql.resultsetMetadata; importar java.sql.sqLexception; importar java.sql.statement; importar java.text.dateFormat; importar java.util.arraylist; importar java.util.date; importar java.util.hashmap; importar java.util.list; importar java.util.map; importar javax.naming.initialContext; importar javax.sql.datasource; // importar org.apache.log4j.logger; /*** Operação do banco de dados Classe auxiliar*/classe pública dbutils {// private static logger logger = logger.getLogger ("dbutils"); / ** * Esta instrução deve ser uma instrução SQL Insert, Atualizar ou Excluir * @param sql * @param paramList: parâmetro, correspondente ao espaço reservado na instrução sql * @return * @throws excepção */ public int Execute (string sql, list <ject> paramlist) throws Exception {se (sql===== //logger.info("parameter é válido! "); } Conexão conn = null; Preparado PSTMT de estatuto preparado = null; int resultado = 0; tente {conn = getConnection (); pstmt = dbutils.getPreparedStatement (Conn, SQL); setPreparedStatementParam (PSTMT, paramlist); if (pstmt == null) {return -1; } resultado = pstmt.executeUpdate (); } catch (Exceção e) {//logger.info (e.getMessage ()); lançar uma nova exceção (e); } finalmente {estreita fechada (pstmt); ClosConn (Conn); } resultado de retorno; } / *** Converta o conjunto de resultados obtido consultando o banco de dados em um objeto de mapa* @param sql: declaração de consulta* @param paramList: parâmetro* @return* / public list <pp <string, object>> getQlist (string sql, list) //logger.info("parameter é válido! "); retornar nulo; } Conexão conn = null; Preparado PSTMT de estatuto preparado = null; ResultSet rs = null; List <map <string, objeto >> QueryList = null; tente {conn = getConnection (); pstmt = dbutils.getPreparedStatement (Conn, SQL); setPreparedStatementParam (PSTMT, paramlist); if (pstmt == null) {return null; } rs = getResultSet (pstmt); queryList = getQueryList (rs); } catch (runTimeException e) {//logger.info (e.getMessage ()); System.out.println ("O parâmetro é válido!"); lançar uma nova exceção (e); } finalmente {CloseResultSet (rs); destacamento próximo (PSTMT); ClosConn (Conn); } retornar querylist; } private void setPreparedStatementParam (preparado PSTMT, list <ject> paramList) lança exceção {if (pstmt == null || paramList == null || paramList.isEmpty ()) {return; } DateFormat df = dateFormat.getDateTimeInstance (); for (int i = 0; i <paramlist.size (); i ++) {if (paramList.get (i) instância do número inteiro) {int paramvalue = ((inteiro) paramList.get (i)). intvalue (); pstmt.setInt (i+1, paramvalue); } else if (paramList.get (i) instância do float) {float paramvalue = ((float) paramlist.get (i)). floatValue (); pstmt.setFloat (i+1, paramvalue); } else if (paramList.get (i) instância do duplo) {duplo paramvalue = ((duplo) paramlist.get (i)). DoubleValue (); pstmt.setDouble (i+1, paramvalue); } else if (paramlist.get (i) instanceof date) {pstmt.SetString (i+1, df.format ((date) paramList.get (i)); } else if (paramlist.get (i) instância de long) {long paramvalue = ((long) paramlist.get (i)). longValue (); pstmt.setlong (i+1, paramvalue); } else if (paramlist.get (i) instância de long) {long paramvalue = ((long) paramlist.get (i)). longValue (); pstmt.setlong (i+1, paramvalue); } else if (paramlist.get (i) instanceof string) {pstmt.setstring (i+1, (string) paramList.get (i)); } } retornar; } / ** * Obtenha conexão com o banco de dados * @return * @throws Exception * / private conexão getConnection () lança Exceção {InitialContext cxt = new InitialContext (); DataSource DS = (DataSource) cxt.lookup (Jndiname); if (ds == null) {lança nova exceção ("fonte de dados não encontrada!"); } retornar ds.getConnection (); } Private estático preparado estatamento getPreparedStatement (conexão conn, string sql) lança exceção {if (conn == null || sql == null || sql.trim (). equals ("")) {return null; } Preparadostatement pstmt = Conn.Preparestatement (sql.trim ()); retornar Pstmt; } / ** * Obtenha conjunto de resultados de consulta do banco de dados * @param pstmt * @return * @throws Exception * / Private ResultSet getResultSet (preparado pstmt) lança exceção {if (pstmt == null) {return null; } ResultSet rs = pstmt.executeQuery (); retornar RS; } / ** * @param rs * @return * @throws Exception * / Private List <Map <String, Object >> getQueryList (ResultSet RS) lança a exceção {if (rs == null) {return null; } ResultSetMetadata rsmetadata = rs.getMetadata (); int colunCount = rsmetadata.getColumnCount (); List <map <string, objeto >> Datalist = new ArrayList <map <string, object >> (); while (rs.Next ()) {map <string, object> datamap = new hashmap <string, object> (); for (int i = 0; i <columnCount; i ++) {datamap.put (rsmetadata.getColumnName (i+1), rs.getObject (i+1)); } datalist.add (datamap); } retornar datalist; } / *** Feche a conexão do banco de dados* @param conn* / private void closeconn (conexão conn) {if (conn == null) {return; } tente {Conn.Close (); } catch (sqlexception e) {//logger.info (e.getMessage ()); }} / *** Fechar* @param stmt* / private privatEnsent (declaração stmt) {if (stmt == null) {return; } tente {stmt.close (); } catch (sqlexception e) {//logger.info (e.getMessage ()); }} / *** Fechar* @param rs* / private void CloseResultSet (ResultSet rs) {if (rs == null) {return; } tente {rs.close (); } catch (sqlexception e) {//logger.info (e.getMessage ()); }} private String jndiname = "java:/comp/Env/jdbc/demodb"; public void setjndiname (String jndiname) {this.jndiname = jndiname; }}Resumo: use o método de configurar fontes de dados para conectar -se ao banco de dados. Este método é eficiente e estável, por isso é recomendável usá -lo.
Para ver mais sintaxe Java, você pode seguir: "Pensando no manual chinês Java", "Manual de Referência JDK 1.7 Versão Oficial em Inglês", "JDK 1.6 API Java Chinese Reference Manual", "JDK 1.5 API Java Chinese Reference Manual". Eu também espero que todos apoiem mais wulin.com.