一、连接数据库

1. 步骤

//1.创建一个Driver实现类的对象
Driver driver = new com.mysql.jdbc.Driver();//注意抛异常 //2.准备 url 和 info
String url = "jdbc:mysql://localhost:3306/test";
//Oracle:"jdbc:oracle:thin:@localhost:1512:sid"
//SQLServer:"jdbc:microsoft:sqlserver//localhost:1433:DatabaseName=sid"
//MySql:"jdbc:mysql://localhost:3306/sid" Properties info = new Properties();
info.put("user", "root");
info.put("password","1230"); //3.获取连接
Connection connection = driver.connect(url, info);//注意抛异常

2. 获取Driver的方式

  • 通过new新建  :Driver driver = new com.mysql.jdbc.Driver();
  • 通过反射创建类的实例  :Driver driver = (Driver)Class.forName(driverClass).newInstance();  //driverClass为全类名,即 com.mysql.jdbc.Driver
  • 通过DriverManager获取数据库连接(加载数据库驱动程序 即 注册驱动)  :DriverManager.registerDriver(Class.forName(driverClass).newInstance());   可简化为 Class.forName(driverClass); 可加载多个驱动
    //加载数据库驱动程序 (可加载多个驱动程序)(注册驱动)
    //DriverManager.registerDriver(Class.forName(driverClass).newInstance());
    Class.forName(driverClass);
    Class.forName(driverClass2); //通过getConnection方法获得连接
    //getConnection(String url, String user, String password) throws SQLException
    Connection connection = DriverManager.getConnection(jdbcUrl, user, password);

3. 提取方法来获得Connection

实现方式:把URL、账号、密码等信息放入 jdbc.properties 文件,通过反射获取

public class Utils {
public Connection getConnection() throws Exception {
String driverClass = null;
String jdbcUrl = null;
String user = null;
String password = null; // 读取类路径下的jdbc.properties文件
InputStream in = getClass().getClassLoader().getResourceAsStream("jdbc.properties");
Properties properties = new Properties();
properties.load(in);
driverClass = properties.getProperty("driver");
jdbcUrl = properties.getProperty("jdbcUrl");
user = properties.getProperty("user");
password = properties.getProperty("password"); /* // 通过反射创建类的实例
Driver driver = (Driver) Class.forName(driverClass).newInstance(); Properties info = new Properties();
info.put("user", user);
info.put("password", password);
Connection connection = driver.connect(jdbcUrl, info);*/ Class.forName(driverClass);
Connection connection = DriverManager.getConnection(jdbcUrl, user, password); return connection;
} }

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAASoAAAC4CAIAAADbgTaEAAAZW0lEQVR4nO2d61sUR77HeXP+j/PmPM9mn32SZbNqMkaXhBjd3bNecjbxRLNHYk5ml4RNzqoxiALeEbyNQaIgigFBgheCyogYNaABVNAkCiIDIqCiXGZAbs0tfV4001NVXdXdMzTUdM/v8/QLZ7q6umesD1Vd3f2dMNE4utw96TmFqUcKUo8UZB4r7OsfQNe2u/uWJxUauDsAMDthBtblyDj+9HFT97OWrmcP62t/TE3PQdc+6nweuTaHtS0AhCDG6Peso3tzUuq9K1sGGvcON+4erE3quBqfnrzu8w0pn29I2ZyU+qyjG/QDAAJj9NuclPr8ySWxt5yyjA+Njw56PL1a+rkctrAwuxN5gWJzuLDSTrvqakURqWJFtSqbA8CUY4x+XyTuF90X6YsoSqd8fuuHOiF5410rSm7JBVwOW5h6cdFpxxXDtg8Ypx3fCwD4hTH6rd5wWOwooi+/jEeuzblQ3bT9+LUPdp1h16GqnygSxhD6YB7oUQv0A4IAun6CIGi+g/LJmq/Fx3nSMt6We7Hw2Mat+Z+tzvlsdU7dvcdnKhsiVme/FZt7vf7x6aLbjDo09cNK4Pqga6ibKmDphw5PsfW+oSx1HAvDVyAASP0GBwejoqIiIiKioqLkNz0ej/TO4OAgtZa/2Y+KLZliS+ZQw+H4zfmp39YWtYxLy7nW8W7hF6lY3bOhv686xTgSbf3QdxVdIXbWqN0jUfVjjmjxvTnk7aD3AyYFpffzeDySgR6PR34ZFRUlvaRSdbOlz1Xqrjk63N14o8FTcG9YuRy62vXRGmfb415GHTr1myjCnHrR1/nR9HM5bLhLclVMpUE/YFLQB5+ycs3NzaiKLIb7ulvylw8057eeWCEMDx+r6c+uxpbUkmfLPittefScXcckej+0pwpYP8asqN2JrKOdjoJ+QMAwp16kAefrr79ODESpdFalN55btX7Ziw+KYjx3vy2/P5jxfY+8JH3T+vqys81tKu6JhDd+nvuhr/VNqjD0U3NJ9tMGg0/AGNRmPj0ez8aNG9X7PVEURwfcDUcWtVRsWvyrsL66na7sv7qaun+3uOTlxedfXlLy2nuli/9R0uUe0joSrCn7O/OJvnbaw7SloEiq31u5dtAPmBQGXHh4Uu5oOxs1UJdQuHOBUL+x+eTyrtsn/K2E6HtI/aRTPdZ1P/LCn9RPERcCta/7kVcLXQ6bd5bTjnV4zD8CAOAXBuh37+i7z6tjB+u2pn46Y7RxR++NtQ15H+jfXDmkEyknYmQfQ0y9KPsgvAb1SU7GVsR1RWpV3hUgIRAABuh3a98feqrWjjfvfVSxfrx5b8flmLqv35t8tQBgeQzQr/Nu8fWUGZXbX5KWakeEu+HK5KsFAMtj5ANHAAD4BegHANwA/QCAG6AfAHAD9AMAboB+AMAN0A8AuAH6AQA3QD8A4Ebw6nd46wbehwAAUwt//Qa7224dibmZ/uHN9A9/OrZmzZI3oyNnRUfOin5zlvSPhOWLeB8jAEwJ/PUr27mot7Wm/2ld/9O6ztqLny+a23g11VX2ZXTkrMby1MayL6MjZ/E+RgCYEjjrN9jVfHXbrCcV6z0/b+/7eWtPdeLaxXMbLjvqv9sTHTnr/uW99y/tBf0Aq2Kwfv4mFFbsfuvpj4d6mgqeN5983nwybum8iZEnvuxdFc2ogMz/E72P8jmlJ/fwYAhIBQSCCsP0Cyyh8GLiy8IzJ7p88fbrjeWpru/3SYNPl9rgk57/N+EZnnFNpKE5ICECCAKM7P0CSCh8WntZTigc6alrKv3cuT2y4uDCioMLi7dF/HBg4Q8HFp7bGnHz6xXV2SvJjRnhSIqsF53RnwAw3Rg8+PQ3oXCkv1NOKBwZ9LTX7BPai4T2M0L7WeHpOeHpOeFpsfDM6a7PvpQcodianv9H5kiAfUCwYvzUy2QSCke6K4WWHKHlmNCaK7TmCq15Qtvx7p/TSlPmdTXfolehyP8D/QCzMCUznwEnFI4NtAuuNKExTWj8Smg8IDQd7Kre4dz2RueDGo1dIiNORYoS5JEBQQrPCw/UhEKhbrtQlyTU7RDuJXf8sP7sljc6mhjuMfL/WAHWvg7QaYfOEAgGeOpHTSg8ve6V0+teObXu1bNb5lXmxA542lVqoF5MoHd2aDIhyAcEBzz1g4RCIMThqR8kFAIhDv97PgEgZAH9AIAboB8AcAP0AwBumEy/+0BQwrtdmBXQDzAA3u3CrIB+gAHwbhdmBfQDDIB3uzAroB9gALzbhVmxlH4bVrwzPa1t8hxaGha29BDvozAM3u3CrJhbv/LkD8qTV5anrCxPXlmevPKTyJfRl1d327m0RT2AfoBodv0ubVv50+mEe85tdwoTKzM+3rEs8qfT8fXObXcKE384+PHlbVFc2qIe+Ok3+T1TauDdLsyKufW7sHFFy42Mzvq8turM2yficla903I9vbM+r60mszrvi4ub/jaZVjalgH6AGDz66UwoJBpC8Yb3G644Wm8eaiz78saxz1P/908TL8tTq46uOh+/TLMZTRAeVyq/XRoX7ns0EGtnUrvzrQ+PK8WK01o1shN0V2RV2LboEcjvl8aFq2xCfJpDUmHiWPBPhnxodAX6VSCVSpWxapiWNmJB+OvnV0Ih0Z6KvnivKie2uiCh6ti6S/s+2vxORGVObHVBwvXcdd/t+fDcuv9WVw9tf3GHfO/72m1pXDhSTGqMEy/llriUuiVjn966sKrwoymNW+rdIbr7if1hm3h3J62Tdz4hDf1gFH0XeljYHrEVh+LkLwt6P8Pgr5/oT0Kh/P/d19cnJxTeufTt3hXzE5fMiVsUkbhkzsa35+6NWnDkn29HR4Qz5kJLqZ0D0eCURYnVhHCUjdl1E4VZB4Q0dfwvAbaJcs/M+hTylMaF4wVL48KRbl39mGR4tBorEBT6iboTCqX/7AcPHowOuOWEwlGh7/aZ5O9SP0lYMvfmqc0/OXf+WLT9curHWX//z5uVFZQWyGpY1PeRtk20O4pCTP1IQygSECaT41/y4HyvKYetWz9iNInt0ruO/FCgn2EEi36ivoRC6T/b7XYTCYXuh1erj8cmLpkrT71UZq3O/eQvdBemXT/lwJStn6Sedx3R+02NfmpDZtnPcBh8Gk8Q6SfqSCiU/rOH+7qIhEKh90nl0dV7oxbIUy/lGZ9l2//EaFOscaKOwWcA+tHOCpn64ZUie2frRzlslRNR9Q/BAKsP9DOM4NJPE+k/m5pQeHH3h1mf/ldVTmzNicTruXElSVFHPlzAak7EXMX9Q0vRmT1iFIhNaejSD92MboKqft41Ez2Ppn7kRBI+9aJxikp+5NK4cO8Ol9JPVSnG8m4XZsWU+lETCg+8P2/zu28eeH+evGRGzbuvAnqCRV5eYE/D69KPsIlyXqVy7odd2NAz+KR8GkV9tA+IT3dSPjHjygylBt7twqyYUr8ax1wiofB2+qI7N65++ueIOzeuykvtT7fU9LMymqd0BsO7XZgVU+p357vDVcm/lxMKr++ec/f73Pv379PnOUOQ6bYP9AsQU+oHEJTGhZNjRu3pFCPh3S7MCuhnEbCTzGm/m5R3uzAroB9gALzbhVkB/QAD4N0uzIrJ9AMAKwH6AQA3QD8A4AboBwDcCFH9zqT8VrmUpM593gk/AQ9MHyGqX2Fy+PDIGLFUF0Sd3TO7q+32VO+d/vPXargcNn83AUxAiOp3Iul3Q8NjxNJ4JeHmN1GFu2d3sg10OWxhYUwTpB+Q1/rp+ABcAv2siUX0Gxsb86v88W0v9w+NycvC+ONRKYUPru1wXU648U1UQbKNtaHLYQuz2WxUFbzrtPQDgAksol9xcTE1GY1FzpbfPx8clZeZMRkzYzLklzlbfs/a0OWwhYXZ7XZKH+dy2BhrAICOFfQbHR3Ny8vzy8CsTTN6+kflRdJPfpm1aQZrQ0k/p8uh6ACd9jCbw+XE9ZsYq4bhY1Lk3A+pT1GMqB3ZIaVa5fkkuRfV+gEuWEE/URSHhoaKi4slCfWUz0yc2d03Ii+SfvLLzMSZrA0ndPHahr0/8bavgbscdm8R7ORNKQa6hioIahe9WsI/+UDZhwFwxyL6iYiBevrAgwmzOntHpKX5Wf/MmIw31hyV3zmYMIu1oa9VY6LJL5zMwSeyhtSPbo1ia6o2vmqxHplVj8oBAtOPdfQTRbGnpycvL+/atWuaJfdveOVZz4i03GjomBmTsSjxuPzO/g2vsDbEOhW5ufu6QrJ1S3Oh7IEiqYlO/ajVIgdEDo6p5QHuWEc/QRD0936OuFfb3cMlNx/uOlH1x7hjM2Myth//od09LC2OuFdZG6J6eNs42tZR/fDLECq9n3/6Mav1bYzZxy4P8MYi+sknfjpnX3bF2h51D1+81TozJuOt2Jy4rO8b2/sfdQ9Ly65Y1QsPxJjTTh2FUmdLjNCPXa28e++JqMZhANyxgn4BzHzuWDu7tVNgLTvWzmZtSDRfaeaEGBUikqEdpb+DT2waBtePXq1cDrv2qF4e4IoV9BP9v+63dc1rDzsE1rJ1zWusDWm6kCdZyMynd74fvyShTz9sFT7zSa9WLkhM0qiWB3hiEf38vetl46o56ssUHWfAgDWWxCL6WR3KZX7AAoB+ZsD/RyQAUwD6BTXyaRsMPC0J6AcA3AD9AIAboB8AcAP0AwBugH4AwA3QDwC4EaL6QdAgEAyEqH7TGTSIXjP35/o5PJlufUJUv4CDBmn3Xqo/xMOKmdAE9LM+FtFv2oIGdeindnc03D0GoFhEv2kLGgT9AAOxgn7TGTSorh8a6BdGezwd18+XwELVFcIFLY8V9BOnMWgwgN6PoR/mjtNB6RIhXNDyWEQ/0Z+gwT5Xqbvm6HB344Aw5m/QoGH66QhdgXBBy2Md/UR9QYNjg56W/OUDzfmtJ1aMjfodNGhc7+cdHLL7JQgXtDzW0U9n0GBnVXrjuVXrl734oCjGc/fb0uoHfgUN0nqkwPTzbcqSEMIFLY9F9NMZNDg64G44sqilYtPiX4X11e10Zf+1sfXpJIIGJYjW7Y9+vhIUPyBc0PJYQT/9M59Pyh1tZ6MG6hIKdy4Q6jc2n1zedfuEX0GDiigx5cQGqRjr3E+eG2GkCEK4oPWxgn6i7ut+946++7w6drBua+qnM0Ybd/TeWNuQ94FfQYOiKJLXF+jdlvaFB+TcjD57AuGClsci+um86+XWvj/0VK0db977qGL9ePPejssxZTtnB23QIFhjeSyin0467xZfT5lRuf0laal2RLgbrvA+KBYQLmh9Qks/MwH3p4UAoF/QAeGCoQPoBwDcAP0AgBugHwBwA/QDAG6AfgDADdAPALhhbv2uOHcol2sX9/Q/7+B9aACgjbn1++5cijIv8MeS+Cvn93i629jbqT8Azrzx0vKE1IcNBsyt3/kzu6l5gbfPJ1wsdri7HzG2A/2oQCzFdGNu/c4WOvqHxvblVm7LuBK7x/nJ5lP9Q2NSXmCNM95Z9GVAtYaOfnBTN2fMrV/hyVQ0L5BYCk+mBlQr6AdME+bWr6Dgq57+0X25lTuPXt2WfjkhtfSL3cX/Sir6eNPJnv7RgoKvWBvSHomVn99zUPRTi+2jPbin3BejBmmtU1qJP/dH3aH28aCriKgYZEdOrUxElao0IxIBnZhbv7zj6WheILHkHU9nbYin/GFZDxMtC9VPIQYR1Yk+++5gPXxLqEXUr3h61vcGvkf12vAPpsi3J3VRy8VgV6UdkQjoxNz6ZedmdvaOUHu/zt6R7NxM1oasvE1RFCmDT7zNYmmaOlJUVGtQrqWMdlXLk8ejWIemNamn1JBBbPSqIDrGOMyt3+HsLDkdULkczs5ibaiat6l17ie/pa8hqtXAGO/RhrfMvxbE8SiRaqOdxLL1U6tKOyIR0Im59UvPym53D1N7v3b3cHpWNmtDC+vnz89LaOin9tFUIxIBnZhbv7TDuXI6oHJJO5zL2lC1PSvixpQnTGwX6Pti1qCswu/Bp87j8U8/nTO+jIhEQCfm1s+Rkd/aKezLrUw+XJaYdnHtruJ/bjkt5wU6MvJZGyoSxxS/e8KaGsEbHDHxITrtdidZSL0GxqknIzXQ3+NxOWxqV1DUMhGZVdEjEoFAMLd+uw4WKGMC5WXXwQLWhkSzwa47OCmDT3SaXuW6A5atqa8GegNG66R1jirHg521KS48sHbE/skWRlW0YwP8xdz6JaWdUl9YG07n9WZjewjob6yEufULlGnN8AP9ABYhqd/0NmHQD2ARivpN82Qd6AewCEX9ACBIAP0AgBugHwBwA/QDAG6AfgDADdAPALgB+gEAN4JXv6EnNQMt13gfhSlRfaICCCKCUb9fxsfaz9ibM15tzVmgozh2f7PiMVGs6SkfIqVff0fveA7itst4KE+RMcHxI9SmpMXPT4ufn1ZQ4X2rrXo/+nIK9hU/P21/vtv7trss2vd+/Py0+PkXajVqcpdFaxwhui9vSXlH+WUqGbMYU6Kfzl9aV+Fh5pxnRS+25USO9Gp+EqV+rJwUXfd6km3aaQ+09U75fd16Hvflrx9igiiKU6Sfuyw6LT6lCdmv7IC7LFpxDGw68vPJvxcKalN8Dkvl8T8unPUrLi4WBEFPySVJBf+WdgddliQViKLYczv7ccHsJ6de6apI06pDTT9KYJBGWzSwuYJ+06ZfxQV2n6NfP7lkU4HaETYVKHtX2Xze+o2Ojubl5ek0cMY/UpWLKIrD3U2ur17rOv/rhgPzfhlX70uN14/apOlPxaM5Rsholhjl4v0v4wm6iQcNfauQsnTHWPpRzv38iDmkFyVKOtS+DQRt/dqq98vDwolGTLRv/B1KeUk/ljD+9X7y7tj6ERXiL3nrJ4ri0NBQcXGxJKFm4b+c3ERdmnNXPDn1UuOhiN76K6oVqOlHyezT6gpogXzyCvLRcPnZdlrwnqL300oBJNs/M1+C9skZ+6EGE5KxhUgdyLPsqjmFzG8DR0s/d1lKdQfyvlS4NiUtPrpa/pmcjvx872CPXl4ShmGg4fpJu0YGn8ihBoN+ImKgZh84++vVsSUbiGX216s9d5yNh994VPCbpvz/U61AbepF7UlwjV5FuR6XV25vzCEg0SK1UgDJx8nJnkf5V0O3fvpjDpmfQFGS8W0Q+DX4rE3xdmhYIybP6yjl5WIUCRVTL7SqcLT0q7iAVRh8+omi2NPTk5eXd+2axsWDf9/3P9RlfHigJnFGV8kLtzbZRvs97AqYvR+95ek+EcJzGIjN0ZpYwXt4k9RMAVSMCbHQh8nopz9nDfvgii5YmUlD+TZwdOg30XHhbiBdFtmgqeUVa31KMHo/dBCL+uOthKmftCF2shdE534SgiDo6f1KYt5UWeqzPn6Y85v6r2Y+upTFrgP7v8dbJCmg/0+544FDWNQsLSAJk5Cin1oKYFDoJ6mHxtQw9VP7NmQY+nkbqNSNeNsu2pvJA05sdMcur9gFzWS9qOmHjIRp7wSBfvKJn+bIsyTmzbspf6YuJTFvdt8tu50092nRC9c3RLLrwJqu8rJBGLHW32lARfUTExnUehQRZ2yn2DsxXD/9MYf4a3IoQR6D1rchUvWruCA3VvwcjxhkSg5gl+BUy5P7DU39/Jr5PPPRnNtb/0hdznw0RxTFq/+a2VH8wtVVM3sf3KXWQLvQR56iYMNE7ZlPtARtJtVmt9uwXTKC98gWq5ECOIX66Y45RNdO9Ocq+tG+DQKFfpgzygto+LW7tPjo/P1IW2eWr7igOAHDroZPVj9sZhWfmMVmgPjrJ/pz3S9z4X+oLKIo1h5ZfyX6tyXv//r+N/uIbakxy6zQajweXX3yhZ3y51ur6E+oxRWnj2rRfQHqR/k4yv5Nf8whdvFDffDJ+DYwfPrJ51rYiZZvXmR/vpscTFZciCevQLDLY9MhqADKu140rzoq9CPPV7E6FSVNf9eLTN/jpvaqC8PP/frjNaXAL4ygaH0blMGntQkC/azMtGYUBj2a3wbopwro5x/Tmc8b/Gh/G5Rbri1LsNxybUlc2J1ZoQ58G4YA+gEAN0A/AOAG6AcA3AD9AIAboB8AcAP0AwBugH4AwI3g1Q+CBgHLE4z66Q8aVL/4q3U7sKIo4yZr4vlTylNvcCMMEBBBesu1zqBBl8MWZrOxHwew2VSehUELMpMFJcEVz+SQJUA/IBDMHTQoNX077c5Dl8PGWEOg9hQsQy3smTnQDwgYcwcNTjR9yn330lOzvluC2TGBKmlDTDNR5UA/IGDMHTQoN33KM+oTb7MeF8XNpBqo8jQNETME+gEBYe6gQV/Txx59wRI4FTFJeBFfPToeBafsGPQDAsfcQYOEBb74LiTIi5azRO/XyGgI6P2AKcbcQYPkOZjN4cKkUfZxWsF4WB4SnPsBU4u5gwaVqZ74ZCclZ1ojGE9UnDBqxc2DfkDAmDtokJYyqBIgRg3GU08WJMMB4bofYCAmDhoUlU2f7NeUWSTUO2HUkwUpeX7K9E5l2h8AaBKkd73IGB00aEBfpbwRBjCKX0KMYLzncwoxKCbQ211CNxcIvNt8EBFa+kFMIC80G+J4SBIq+kEwHhf89W0sxAgV/YDpR9M6ZXMcDTFAP8B49FuHtsWR0AP0AwxGxT2ldXJDHEYQQgbQDzAY9U6Pap3cHIcQBkMA0A8wEj2dHmEdIduAl/4Q4P8BwqmLKREVjroAAAAASUVORK5CYII=" alt="" />

二、数据库操作

前提:连接数据库的前提下,才能进行操作

1. 执行更新操作 (插入、修改、删除 )

//1.获得连接
Connection conn = driver.connect(url, info);
String sql="..."; //sql语句 //2.获取statement对象
Statement statement = conn.createStatement(); //3.执行
statement.executeUpdate(sql); //4.关闭
statement.close();
conn.close();

2. 查询操作

//1.通过连接获得statement对象
Statement statement = conn.createStatement();
String sql = "..."; //2.执行
ResultSet rs = statement.executeQuery(sql); //3.遍历输出
while(rs.next()){
int id = rs.getInt(1);
String name = rs.getString("name");
} //4.关闭
rs.close();
statement.close();
conn.close();

3. 给SQL语句设置参数——PreparedStatement

父类:Statement

//1.通过连接获得preparedStatement对象
String sql = "insert into customers (name, email, birth) values(?,?,?)";
preparedStatement = conn.prepareStatement(sql);  //与无参的Statement对象不同,获得对象时就得传入sql语句,执行语句时不用再传入sql语句 //2.设置参数
preparedStatement.setString(1, "zhangsan");
preparedStatement.setString(2, "77777@qq.com");
preparedStatement.setDate(3, new Date(new java.util.Date().getTime())); //3.执行
preparedStatement.executeUpdate(); //4.获得ResultSet
ResultSet rs = preparedStatement.getResultSet();

获取插入记录的主键值

实现方式:使用重载的preparedStatement(sql, flag)来生成preparedStatement对象

preparedStatement = conn.preparedStatement(sql, Statement.RETURN_GENERATED_KEYS);

//生成的结果集里只有一列,即主键编号
ResultSet rs = preparedStatement.getGeneratedKeys();
if(rs.next()){

//获得主键
String generatedKey = rs.getObject(1); }

4. 调用函数&存储过程——CallableStatement

父类:Statement

// 1. 通过 Connection 对象的 prepareCall()方法创建一个 CallableStatement 对象的实例。
//sql字符串指明如何调用存储过程:?=call name(param, ..., param) 或 callname(param, ..., param)
String sql = "{?= call sum_salary(?, ?)}";
CallableStatement callableStatement = connection.prepareCall(sql); // 2. 通过 CallableStatement 对象的 reisterOutParameter() 方法注册 OUT 参数。
callableStatement.registerOutParameter(1, Types.NUMERIC);
callableStatement.registerOutParameter(3, Types.NUMERIC); // 3. 通过 CallableStatement 对象的 setXxx() 方法设定 IN 或 IN OUT 参数。
//若想将参数默认值设为null, 可以使用 setNull() 方法。
callableStatement.setInt(2, 80); // 4. 通过 CallableStatement 对象的 execute() 方法执行存储过程。
callableStatement.execute(); // 5. 如果所调用的是带返回参数的存储过程, 还需要通过 CallableStatement 对象的 getXxx() 方法获取其返回值。
double sumSalary = callableStatement.getDouble(1);
long empCount = callableStatement.getLong(3);

三、JDBC元数据

1. ResultSetMetaData

方法签名:ResultSetMetaData getMetaData()       //通过 resultSet.getMetaData() 方法获得 ResultSetMetaData 对象

int getColumnCount()                            //查询结果集中的列数

String getColumnName(int colum)        //获取查询结果集中指定的列别名,从1开始

String getColumnLabel(int colum)         //获取查询结果集中指定的列别名,从1开始

    //在数据库中查询记录,转换成与表相对应的实体类对象
public <T> T get(Class<T> clazz, String sql, Object... args) throws Exception {
T entity = null; Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null; //1.获得connection
connection = getConnection(); //2.设置参数
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
preparedStatement.setObject(i + 1, args[i]);
} //3.执行,并获得resultSet
resultSet = preparedStatement.executeQuery(); //4.通过resultSet获得resultSetMetaData
ResultSetMetaData resultSetMetaData = resultSet.getMetaData(); Map<String, Object> values = new HashMap<>();
if (resultSet.next()) {
//5.把结果放入哈希表中
for (int i = 0; i < resultSetMetaData.getColumnCount(); i++) {
String columnLabel = resultSetMetaData.getColumnLabel(i + 1);
Object columnValue = resultSet.getObject(i + 1); values.put(columnLabel, columnValue);
}

//6.为相应实体类对象设置属性值
if(values.size() > 0){
entity = clazz.newInstance();
for(Map.Entry<String, Object> entry: values.entrySet()){
String fieldName = entry.getKey();
Object value = entry.getValue(); BeanUtils.setProperty(entity, fieldName, value);//需要使用beanutils工具包
}
}
}
return entity;
}

2. DatabaseMetaData

方法签名:DatabaseMetaData getMetaData()      //通过 connection.getMetaData() 方法获得

作用:可以得到数据库本身的一些信息

DatabaseMetaData data = connection.getMetaData();
//1. 得到数据库的版本号
int version = data.getDatabaseMajorVersion(); //2. 得到连接到数据库的用户名
String user = data.getUserName(); //3. 得到 MySQL 中有哪些数据库
ResultSet resultSet = data.getCatalogs();

四、处理Blob大对象数据

LOB:大对象,存储大量数据的一种数据类型。

BLOB:二进制大对象。

1. 读取 Blob 数据

 实现方式:使用 getBlob 方法读取到 Blob 对象

调用 Blob 的 getBinaryStream() 方法得到输入流。再使用 IO 操作即可。

...
resultSet = preparedStatement.executeQuery(); if(resultSet.next()){
int id = resultSet.getInt(1);
String name = resultSet.getString(2);
String email = resultSet.getString(3); //1.获得Blob对象
Blob picture = resultSet.getBlob(5); //2.获得输入流
InputStream in = picture.getBinaryStream(); //3.输出到flower.jpg
OutputStream out = new FileOutputStream("flower.jpg");
byte [] buffer = new byte[1024];
int len = 0;
while((len = in.read(buffer)) != -1){
out.write(buffer, 0, len);
} in.close();
out.close();
}

2. 写入Blob数据

作用:实现将本地图片写入数据库

String sql = "INSERT INTO customers(name, email, birth, picture) VALUES(?,?,?,?)";
//通过连接 获得preparedStatement对象
preparedStatement = connection.prepareStatement(sql);

//设置参数
preparedStatement.setString(1, "ABCDE");
preparedStatement.setString(2, "abcde@atguigu.com");
preparedStatement.setDate(3, new Date(new java.util.Date().getTime()));

//1.创建输入流
InputStream inputStream = new FileInputStream("Hydrangeas.jpg");
//2.设置Blob参数
preparedStatement.setBlob(4, inputStream); preparedStatement.executeUpdate();

五、事务

1. 方法

//取消默认提交后才能进行事务

connection.setAutoCommit(false);  //取消默认提交并开始事务

//提交事务

connection.commit();

//回滚

connection.rollback();

2. 数据库的隔离级别

  • READ UNCOMMITTED  :读未提交数据,允许事务读取未被其他事务提交的变更,脏读、不可重复读、幻读都会出现。
  • READ COMMITTED       :读已提交数据,只允许事务读取已经被其他事务提交的变更。可避免脏读,不可重复读和幻读仍然存在。
  • REPEATABLE READ      :可重复读,确保事务可以多次从一个字段中读取相同的值,在这个事务持续期间,禁止其他事务对这个字段进行更新。可避免脏读和不可重复读,幻读问题仍然存在。
  • SERIALIZABLE          :串行化,确保事务可以从一个表中读取相同的行,在这个事务持续期间,禁止其他事务对该表执行操作,所有并发问题都可避免,但性能低下。

通过Connection的setTransactionIsolation来设置事务的隔离级别。

例:connection.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);

注:mysql的默认隔离级别是REPEATABLE READ。

六、批量处理

方法签名:preparedStatement.addBatch();         //加入Batch

preparedStatement.executeBatch();  //批量处理

preparedStatement.clearBatch();      //清除当前的积累量

//批量插入十万条数据
sql = "INSERT INTO customers VALUES(?,?,?)";
preparedStatement = connection.prepareStatement(sql);
Date date = new Date(new java.util.Date().getTime());
for(int i = 0; i < 100000; i++){
preparedStatement.setInt(1, i + 1);
preparedStatement.setString(2, "name_" + i);
preparedStatement.setDate(3, date); //"积攒" SQL
preparedStatement.addBatch();  //Statement写法:statement.addBatch(String sql); //当 "积攒" 到一定程度, 就统一的执行一次. 并且清空先前 "积攒" 的 SQL
if((i + 1) % 300 == 0){
preparedStatement.executeBatch();
preparedStatement.clearBatch();
}
} //若总条数不是批量数值的整数倍, 则还需要再额外的执行一次.
if(100000 % 300 != 0){
preparedStatement.executeBatch();
preparedStatement.clearBatch();
}

七、数据库连接池

必要性

传统连接使用DriverManager获取,再验证用户名密码,执行完毕再断开连接。数据库的连接资源没有得到很好的重复利用。

数据库连接池负责分配、管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个。

数据库连接池是通过实现DataSource接口来实现的。

1. DBCP

需要2 个jar 包:

  • dbcp
  • pool

注:dbcp依赖于 pool

final BasicDataSource dataSource = new BasicDataSource();

//1. 为数据源实例指定必须的属性
dataSource.setUsername("root");
dataSource.setPassword("1230");
dataSource.setUrl("jdbc:mysql://localhost:3306/test");
dataSource.setDriverClassName("com.mysql.jdbc.Driver"); //2. 指定数据源的一些可选的属性
//1). 指定数据库连接池中初始化连接数的个数
dataSource.setInitialSize(5); //2). 指定最大的连接数: 同一时刻可以同时向数据库申请的连接数
dataSource.setMaxActive(5); //3). 指定小连接数: 在数据库连接池中保存的最少的空闲连接的数量
dataSource.setMinIdle(2); //4).等待数据库连接池分配连接的最长时间. 单位为毫秒. 超出该时间将抛出异常.
dataSource.setMaxWait(1000 * 5); //3. 从数据源中获取数据库连接
Connection connection = dataSource.getConnection();

通过DataSourceFactory创建连接池(DataSource),这样可以直接从配置文件中获取信息

//从Properties文件里获得数据
Properties properties = new Properties();
InputStream inStream = DBCPTest.class.getClassLoader().getResourceAsStream("dbcp.properties");
properties.load(inStream);

//使用工厂创建连接池
DataSource dataSource = BasicDataSourceFactory.createDataSource(properties);

aaarticlea/png;base64,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" alt="" width="413" height="186" />

2. C3P0

@Test
public void testC3P0() throws Exception{
ComboPooledDataSource cpds = new ComboPooledDataSource();
cpds.setDriverClass( "com.mysql.jdbc.Driver" ); //loads the jdbc driver
cpds.setJdbcUrl( "jdbc:mysql://localhost:3306/test" );
cpds.setUser("root");
cpds.setPassword("1230"); System.out.println(cpds.getConnection());
}

通过加载配置文件来获得信息

DataSource dataSource = new ComboPooledDataSource("helloc3p0");

dataSource.getConnection();

<!-- 配置文件helloc3p0.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
<named-config name="helloc3p0"> <!-- 指定连接数据源的基本属性 -->
<property name="user">root</property>
<property name="password">1230</property>
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql:///atguigu</property> <!-- 若数据库中连接数不足时, 一次向数据库服务器申请多少个连接 -->
<property name="acquireIncrement">5</property>
<!-- 初始化数据库连接池时连接的数量 -->
<property name="initialPoolSize">5</property>
<!-- 数据库连接池中的最小的数据库连接数 -->
<property name="minPoolSize">5</property>
<!-- 数据库连接池中的最大的数据库连接数 -->
<property name="maxPoolSize">10</property> <!-- C3P0 数据库连接池可以维护的 Statement 的个数 -->
<property name="maxStatements">20</property>
<!-- 每个连接同时可以使用的 Statement 对象的个数 -->
<property name="maxStatementsPerConnection">5</property>
</named-config>
</c3p0-config>

八、DBUtils

注:dbutils只是对底层的封装

QueryRunner可能会有线程安全问题,逐一不要创建多个实例

1. update方法

//1.创建QueryRunner实现类
QueryRunner queryRunner = new QueryRunner();
String sql = "DELETE FROM customers WHERE id IN (?,?)"; //2.使用update方法
queryRunner.update(connection, sql, 12, 13);

2. query方法

方法签名:queryRunner.query(Connection connection, String sql, ResultSetHandler rs);

使用:在实现ResultSetHandler接口的类的handle方法中编写对结果集的处理方法。

Object object = queryRunner.query(conn, sql, new ResultSetHandler() {
@Override
public Object handle(ResultSet rs) throws SQLException {
List<Customer> customers = new ArrayList<>(); while (rs.next()) {
int id = rs.getInt(1);
String name = rs.getString(2);
String email = rs.getString(3);
Date birth = rs.getDate(4); Customer customer = new Customer(id, name, email, birth);
customers.add(customer);
}
//也是query方法的返回值
return customers;
}
});

以下Handler类实现了ResultSetHandler接口

1)BeanHandler

功能:返回查询的第一条记录对应的那个实体类对象

原理:BeanHandler类的handle方法中通过反射创建传入的Class类对应的类的对象,并用set方法为该对象设置属性,然后返回该对象。

注意:查询语句中的列名要和实体类的属性相对应,若不对应则需要使用别名   如下name:

String sql = "SELECT id, name customerName, email, birth FROM customers WHERE id >= ?";

// 1. 创建 QueryRunner 对象
QueryRunner queryRunner = new QueryRunner();

// 2. 调用query方法
Object object = queryRunner.query(conn, sql, new BeanHandler<>(Customer.class),5);

2)BeanListHandler

作用:可以通过查询记录获得实体类对象集合

若可以查询到记录,则返回传入的Class对象对应的对象集合。

String sql = "SELECT id, name customerName, email, birth FROM customers";
QueryRunner queryRunner = new QueryRunner();

// 返回List<Customer> 对象
Object object = queryRunner.query(conn, sql, new BeanListHandler<>(Customer.class));

3)MapHandler

作用:返回查询的第一条记录对应的Map对象  键:列名(非别名);值:列的值

QueryRunner queryRunner = new QueryRunner();
String sql = "SELECT id, name customerName, email, birth FROM customers WHERE id = ?"; Map<String, Object> map = queryRunner.query(connection, sql, new MapHandler(), 4);

4)MapListHandler

作用:返回查询的所有记录对应的Map对象的集合

QueryRunner queryRunner = new QueryRunner();
String sql = "SELECT id, name, email, birth FROM customers"; List<Map<String, Object>> mapList = queryRunner.query(connection, sql, new MapListHandler());

5)ScalarHandler

作用:返回结果集中的第一列对应的数据

QueryRunner queryRunner = new QueryRunner();
String sql = "SELECT name FROM customers WHERE id = ?"; Object count = queryRunner.query(connection, sql, new ScalarHandler(), 6);

3. QueryLoader

作用:可以用来加载存放着 SQL 语句的资源文件。

使用该类可以把 SQL 语句外置化到一个资源文件中. 以提供更好的解耦。

// / 代表类路径的根目录
Map<String, String> sqls = QueryLoader.instance().load("/sql.properties"); String updateSql = sqls.get("UPDATE_CUSTOMER");

aaarticlea/png;base64,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" alt="" width="659" height="61" />

最新文章

  1. 一个Java内存可见性问题的分析
  2. java常用方法总结
  3. sdut 2165:Crack Mathmen(第二届山东省省赛原题,数论)
  4. iOS开发 字符串MD5加密
  5. c#使用正则表达式替换html标签
  6. Java 控制反转和依赖注入模式【翻译】【整理】
  7. lucene3.6笔记添加搜索功能
  8. git merge,rebase和*(no branch)
  9. CF #356 div1 A. Bear and Prime 100
  10. CF908D Arbitrary Arrangement
  11. golang:一个高性能低精度timer实现
  12. ASP.NET Core2.2+Quartz.Net 实现web定时任务
  13. 当linux报 “-bash: fork: 无法分配内存”
  14. iOS利用xcodebuild命令自动打包方法
  15. java中解析excel 批量插入数据库
  16. jquery parents() next() prev() 找父级别标签 找同级别标签
  17. 基于Apache的阿里云部署Node.js服务器(Windows环境)
  18. 访问服务器时一直在转圈,等待localhost响应
  19. linux将80端口映射到指定端口命令
  20. 【Linux】CentOS安装solr 4.10.3

热门文章

  1. 云端卫士实战录 | Java高级特性之多线程
  2. VBPR: Visual Bayesian Personalized Ranking from Implicit Feedback-AAAI2016 -20160422
  3. 【8-16】Android学习笔记01
  4. Lambda表达式与标准运算符查询
  5. CSS实现标题右侧“更多”
  6. [Objective-c 基础 - 2.5] .h和.m文件,点语法,成员变量作用域
  7. git分享:Git_DataPro
  8. Apache POI组件操作Excel,制作报表(二)
  9. Windows 小端存储
  10. ios电话拨打进行监听电话状态
  11. 《连载 | 物联网框架ServerSuperIO教程》- 15.数据持久化接口的使用。附:3.2发布与版本更新说明。
  12. 自定义分布式RESTful API鉴权机制
  13. linux内核管理
  14. 新建swap分区的规划、挂载和自动挂载示例
  15. [strongswan][autoconf][automake][cento] 在CentOS上编译strongswan git源码时遇到的autoconf问题
  16. python2.7安装pip遇到ImportError: cannot import name HTTPSHandle
  17. zabbix 监控基础
  18. Kafka设计原理
  19. 【转】android IDE——通过DDMS查看app运行时所占内存情况
  20. Java并发程序设计(七)乐天派:无锁