1. package pl.polsl.zti.db1.dao;
2.  
3. import java.sql.Connection;
4. import java.sql.PreparedStatement;
5. import java.sql.ResultSet;
6. import java.sql.SQLException;
7. import java.sql.Statement;
8. import java.util.ArrayList;
9. import java.util.List;
10. import pl.polsl.zti.db1.domain.Client;
11. import pl.polsl.zti.db1.util.JdbcUtils;
12.  
13. public class ClientDaoImplJdbc implements ClientDao {
14.  
15.     @Override
16.     public Client getClient(int id) {
17.         Client client = null;
18.         Connection con = null;
19.         PreparedStatement preparedStatement = null; // polecenie prekompilowane        
20.         try {
21.             con = JdbcUtils.getConnection();
22.             preparedStatement = con.prepareStatement("SELECT * FROM CLIENTS WHERE id = ?");
23.             preparedStatement.setInt(1, id); // ustawia wartość parametru
24.  
25.             final ResultSet resultSet = preparedStatement.executeQuery();
26.             if (resultSet.next()) {
27.                 client = readClient(resultSet);
28.             }
29.         } catch (SQLException ex) {
30.             JdbcUtils.handleSqlException(ex);
31.         } finally {
32.             JdbcUtils.closeSilently(preparedStatement, con);
33.         }
34.  
35.         return client;
36.     }
37.  
38.     @Override
39.     public List<Client> getClients() {
40.         // lista klientów do zwrócenia               
41.         final List<Client> clients = new ArrayList<Client>();
42.  
43.         Connection con = null;
44.         Statement stmt = null;
45.         try {
46.             con = JdbcUtils.getConnection();
47.             stmt = con.createStatement();
48.             final ResultSet resultSet = stmt.executeQuery("SELECT ID, CLIENT_NO, NAME, SSN, ADDRESS FROM CLIENTS");
49.             while (resultSet.next()) {
50.                 // utwórz nowy obiekt typu Client
51.                 final Client client = readClient(resultSet);
52.                 // dodaj klienta do listy
53.                 clients.add(client);
54.             }
55.         } catch (SQLException ex) {
56.             JdbcUtils.handleSqlException(ex);
57.         } finally {
58.             JdbcUtils.closeSilently(stmt, con);
59.         }
60.  
61.         return clients;
62.     }
63.  
64.     @Override
65.     public List<Client> getClients(String name) {
66.         // Zaimplementować pobieranie z bazy klientów według nazwy.
67.         // Znak '_' zastępuje dowolny znak we wzorcu,
68.         // znak '%' zastępuje dowolny ciąg znaków we wzorcu
69.         // (wykorzystać operator LIKE).
70.         // Wartość null w miejscu kryterium powoduje, ze nie jest ono brane pod uwagę.
71.         // Przykłady:
72.         //   * wywołanie getClients(null) ma zwrócić wszystkich klientów
73.         //   * wywołanie getClients("A%") ma zwrócić wszystkich klientów,
74.         //         których nazwy zaczynają się na literę 'A'
75.  
76.         final List<Client> clients = new ArrayList<Client>();
77.  
78.         Connection con = null;
79.         Statement stmt = null;
80.         String command;
81.         if (name != null)
82.                 command = "SELECT ID, CLIENT_NO, NAME, SSN, ADDRESS FROM CLIENTS WHERE NAME LIKE "" + name + """;
83.         else
84.                 command = "SELECT ID, CLIENT_NO, NAME, SSN, ADDRESS FROM CLIENTS";
85.                
86.         try {
87.             con = JdbcUtils.getConnection();
88.             stmt = con.createStatement();
89.             final ResultSet resultSet = stmt.executeQuery(command);
90.             while (resultSet.next()) {
91.                 // utwórz nowy obiekt typu Client
92.                 final Client client = readClient(resultSet);
93.                 // dodaj klienta do listy
94.                 clients.add(client);
95.             }
96.         } catch (SQLException ex) {
97.             JdbcUtils.handleSqlException(ex);
98.         } finally {
99.             JdbcUtils.closeSilently(stmt, con);
100.         }
101.  
102.         return clients;
103.     }
104.  
105.     private Client readClient(final ResultSet rs) throws SQLException {
106.         // utwórz nowy obiekt typu Client
107.         final Client client = new Client();
108.         // przypisz wartości do poszczególnych pól klienta
109.         client.setId(rs.getInt("ID"));
110.         client.setNo(rs.getInt("CLIENT_NO"));
111.         client.setName(rs.getString("NAME"));
112.         client.setSsn(rs.getString("SSN"));
113.         client.setAddress(rs.getString("ADDRESS"));
114.         return client;
115.     }
116.  
117.     @Override
118.     public void insertClients(List<Client> clients) {
119.         // Zaimplementować wstawianie do bazy podanej listy klientów.
120.         // Wstawianie wszystkich klientów ma być przeprowadzone w ramach jednej transakcji.
121.         // Proszę wykorzystać polecenia prekompilowane.
122.  
123.         Connection con = null;
124.         PreparedStatement pstmt = null;
125.         try {
126.             con = JdbcUtils.getConnection();
127.             pstmt = con.prepareStatement("INSERT INTO clients VALUES (?,?,?,?,?)");
128.             for (Client cln : clients) {
129.                 con.setAutoCommit(false);
130.                 pstmt.setInt(1, cln.getId());
131.                 pstmt.setInt(2, cln.getNo());
132.                 pstmt.setString(3, cln.getName());
133.                 pstmt.setString(4, cln.getSsn());
134.                 pstmt.setString(5, cln.getAddress());
135.                 pstmt.executeUpdate();
136.                 con.commit();
137.             }
138.         } catch (SQLException ex) {
139.             JdbcUtils.handleSqlException(ex);
140.         } finally {
141.             JdbcUtils.closeSilently(pstmt, con);
142.         }
143.     }
144.  
145.     @Override
146.     public void updateClient(Client client) {
147.         // Zaimplementować aktualizację danych podanego klienta w bazie.     
148.  
149.         Connection con = null;
150.         PreparedStatement pstmt = null;
151.         try {
152.             con = JdbcUtils.getConnection();
153.             pstmt = con.prepareStatement("UPDATE clients SET CLIENT_NO=?, NAME=?, SSN=?, ADDRESS=? WHERE ID=?");
154.            
155.             pstmt.setInt(1, client.getNo());
156.             pstmt.setString(2, client.getName());
157.             pstmt.setString(3, client.getSsn());
158.             pstmt.setString(4, client.getAddress());
159.             pstmt.setInt(5, client.getId());
160.             pstmt.executeUpdate();
161.            
162.         } catch (SQLException ex) {
163.             JdbcUtils.handleSqlException(ex);
164.         } finally {
165.             JdbcUtils.closeSilently(pstmt, con);
166.         }
167.     }
168.  
169.     @Override
170.     public void deleteClient(int id) {
171.         Connection con = null;
172.         Statement stmt = null;
173.         try {
174.             con = JdbcUtils.getConnection();
175.             stmt = con.createStatement();
176.             stmt.executeUpdate("DELETE FROM CLIENTS WHERE id = " + id);
177.         } catch (SQLException ex) {
178.             JdbcUtils.handleSqlException(ex);
179.         } finally {
180.             JdbcUtils.closeSilently(stmt, con);
181.         }
182.     }
183.  
184.     @Override
185.     public void deleteClient(Client client) {
186.         deleteClient(client.getId());
187.     }
188. }
189.