API tools faq
paste
Advertisement
adwas33

Untitled

adwas33
May 21st, 2023
31
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 15.94 KB | None | 0 0
raw download clone embed print report
  1. Przykładowe metody DAO mogą wyglądać tak:
  2.  
  3. ```java
  4. import org.hibernate.Session;
  5. import org.hibernate.Transaction;
  6.  
  7. public class UserDataDao {
  8.  
  9. public void saveUserData(UserData userData) {
  10. Transaction transaction = null;
  11. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  12. // start a transaction
  13. transaction = session.beginTransaction();
  14. // save the student object
  15. session.save(userData);
  16. // commit transaction
  17. transaction.commit();
  18. } catch (Exception e) {
  19. if (transaction != null) {
  20. transaction.rollback();
  21. }
  22. e.printStackTrace();
  23. }
  24. }
  25.  
  26. public void updateUser(UserData userData) {
  27. Transaction transaction = null;
  28. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  29. // start a transaction
  30. transaction = session.beginTransaction();
  31. // save the student object
  32. session.update(userData);
  33. // commit transaction
  34. transaction.commit();
  35. } catch (Exception e) {
  36. if (transaction != null) {
  37. transaction.rollback();
  38. }
  39. e.printStackTrace();
  40. }
  41. }
  42.  
  43. public void deleteUser(Long id) {
  44. Transaction transaction = null;
  45. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  46. // start a transaction
  47. transaction = session.beginTransaction();
  48.  
  49. // Delete a user object
  50. UserData userData = session.get(UserData.class, id);
  51. if (userData != null) {
  52. session.delete(userData);
  53. System.out.println("user is deleted");
  54. }
  55.  
  56. // commit transaction
  57. transaction.commit();
  58. } catch (Exception e) {
  59. if (transaction != null) {
  60. transaction.rollback();
  61. }
  62. e.printStackTrace();
  63. }
  64. }
  65.  
  66. public UserData getUser(Long id) {
  67.  
  68. Transaction transaction = null;
  69. UserData userData = null;
  70. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  71. // start a transaction
  72. transaction = session.beginTransaction();
  73. // get an user object
  74. userData = session.get(UserData.class, id);
  75. // commit transaction
  76. transaction.commit();
  77. } catch (Exception e) {
  78. if (transaction != null) {
  79. transaction.rollback();
  80. }
  81. e.printStackTrace();
  82. }
  83. return userData;
  84. }
  85. }
  86. ```
  87.  
  88. W powyższym kodzie:
  89. - `saveUserData(UserData userData)` zapisuje nowy obiekt UserData do bazy danych.
  90. - `updateUser(UserData userData)` aktualizuje istniejący obiekt UserData w bazie danych.
  91. - `deleteUser(Long id)` usuwa obiekt UserData z bazy danych na podstawie jego id.
  92. - `getUser(Long id)` pobiera obiekt UserData z bazy danych na podstawie jego id.
  93.  
  94. Do poprawnego działania powyższego kodu, potrzebujesz klasy `HibernateUtil`, która dostarcza obiekt `SessionFactory`. `SessionFactory` jest używany do otwierania nowych sesji Hibernate. Poniżej znajduje się przykładowa klasa `HibernateUtil`:
  95.  
  96. ```java
  97. import org.hibernate.HibernateException;
  98. import org.hibernate.SessionFactory;
  99. import org.hibernate.cfg.Configuration;
  100.  
  101. public class HibernateUtil {
  102. private static final SessionFactory sessionFactory;
  103.  
  104. static {
  105. try {
  106. sessionFactory = new Configuration().configure().buildSessionFactory();
  107. } catch (HibernateException ex) {
  108. throw new ExceptionInInitializerError(ex);
  109. }
  110. }
  111.  
  112. public static SessionFactory getSessionFactory() {
  113. return sessionFactory;
  114. }
  115. }
  116. ```
  117.  
  118. Zauważ, że powyższe metody DAO są niskopoziomowe i nie zapewniają żadnej logiki biznesowej. W prawdziwym projek
  119.  
  120. Przykładowe metody DAO mogą wyglądać tak:
  121.  
  122. ```java
  123. import org.hibernate.Session;
  124. import org.hibernate.Transaction;
  125.  
  126. public class UserDataDao {
  127.  
  128. public void saveUserData(UserData userData) {
  129. Transaction transaction = null;
  130. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  131. // start a transaction
  132. transaction = session.beginTransaction();
  133. // save the student object
  134. session.save(userData);
  135. // commit transaction
  136. transaction.commit();
  137. } catch (Exception e) {
  138. if (transaction != null) {
  139. transaction.rollback();
  140. }
  141. e.printStackTrace();
  142. }
  143. }
  144.  
  145. public void updateUser(UserData userData) {
  146. Transaction transaction = null;
  147. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  148. // start a transaction
  149. transaction = session.beginTransaction();
  150. // save the student object
  151. session.update(userData);
  152. // commit transaction
  153. transaction.commit();
  154. } catch (Exception e) {
  155. if (transaction != null) {
  156. transaction.rollback();
  157. }
  158. e.printStackTrace();
  159. }
  160. }
  161.  
  162. public void deleteUser(Long id) {
  163. Transaction transaction = null;
  164. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  165. // start a transaction
  166. transaction = session.beginTransaction();
  167.  
  168. // Delete a user object
  169. UserData userData = session.get(UserData.class, id);
  170. if (userData != null) {
  171. session.delete(userData);
  172. System.out.println("user is deleted");
  173. }
  174.  
  175. // commit transaction
  176. transaction.commit();
  177. } catch (Exception e) {
  178. if (transaction != null) {
  179. transaction.rollback();
  180. }
  181. e.printStackTrace();
  182. }
  183. }
  184.  
  185. public UserData getUser(Long id) {
  186.  
  187. Transaction transaction = null;
  188. UserData userData = null;
  189. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  190. // start a transaction
  191. transaction = session.beginTransaction();
  192. // get an user object
  193. userData = session.get(UserData.class, id);
  194. // commit transaction
  195. transaction.commit();
  196. } catch (Exception e) {
  197. if (transaction != null) {
  198. transaction.rollback();
  199. }
  200. e.printStackTrace();
  201. }
  202. return userData;
  203. }
  204. }
  205. ```
  206.  
  207. W powyższym kodzie:
  208. - `saveUserData(UserData userData)` zapisuje nowy obiekt UserData do bazy danych.
  209. - `updateUser(UserData userData)` aktualizuje istniejący obiekt UserData w bazie danych.
  210. - `deleteUser(Long id)` usuwa obiekt UserData z bazy danych na podstawie jego id.
  211. - `getUser(Long id)` pobiera obiekt UserData z bazy danych na podstawie jego id.
  212.  
  213. Do poprawnego działania powyższego kodu, potrzebujesz klasy `HibernateUtil`, która dostarcza obiekt `SessionFactory`. `SessionFactory` jest używany do otwierania nowych sesji Hibernate. Poniżej znajduje się przykładowa klasa `HibernateUtil`:
  214.  
  215. ```java
  216. import org.hibernate.HibernateException;
  217. import org.hibernate.SessionFactory;
  218. import org.hibernate.cfg.Configuration;
  219.  
  220. public class HibernateUtil {
  221. private static final SessionFactory sessionFactory;
  222.  
  223. static {
  224. try {
  225. sessionFactory = new Configuration().configure().buildSessionFactory();
  226. } catch (HibernateException ex) {
  227. throw new ExceptionInInitializerError(ex);
  228. }
  229. }
  230.  
  231. public static SessionFactory getSessionFactory() {
  232. return sessionFactory;
  233. }
  234. }
  235. ```
  236.  
  237. Zauważ, że powyższe metody DAO są niskopoziomowe i nie zapewniają żadnej logiki biznesowej. W prawdziwym projek
  238.  
  239. Przykładowe metody DAO mogą wyglądać tak:
  240.  
  241. ```java
  242. import org.hibernate.Session;
  243. import org.hibernate.Transaction;
  244.  
  245. public class UserDataDao {
  246.  
  247. public void saveUserData(UserData userData) {
  248. Transaction transaction = null;
  249. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  250. // start a transaction
  251. transaction = session.beginTransaction();
  252. // save the student object
  253. session.save(userData);
  254. // commit transaction
  255. transaction.commit();
  256. } catch (Exception e) {
  257. if (transaction != null) {
  258. transaction.rollback();
  259. }
  260. e.printStackTrace();
  261. }
  262. }
  263.  
  264. public void updateUser(UserData userData) {
  265. Transaction transaction = null;
  266. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  267. // start a transaction
  268. transaction = session.beginTransaction();
  269. // save the student object
  270. session.update(userData);
  271. // commit transaction
  272. transaction.commit();
  273. } catch (Exception e) {
  274. if (transaction != null) {
  275. transaction.rollback();
  276. }
  277. e.printStackTrace();
  278. }
  279. }
  280.  
  281. public void deleteUser(Long id) {
  282. Transaction transaction = null;
  283. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  284. // start a transaction
  285. transaction = session.beginTransaction();
  286.  
  287. // Delete a user object
  288. UserData userData = session.get(UserData.class, id);
  289. if (userData != null) {
  290. session.delete(userData);
  291. System.out.println("user is deleted");
  292. }
  293.  
  294. // commit transaction
  295. transaction.commit();
  296. } catch (Exception e) {
  297. if (transaction != null) {
  298. transaction.rollback();
  299. }
  300. e.printStackTrace();
  301. }
  302. }
  303.  
  304. public UserData getUser(Long id) {
  305.  
  306. Transaction transaction = null;
  307. UserData userData = null;
  308. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  309. // start a transaction
  310. transaction = session.beginTransaction();
  311. // get an user object
  312. userData = session.get(UserData.class, id);
  313. // commit transaction
  314. transaction.commit();
  315. } catch (Exception e) {
  316. if (transaction != null) {
  317. transaction.rollback();
  318. }
  319. e.printStackTrace();
  320. }
  321. return userData;
  322. }
  323. }
  324. ```
  325.  
  326. W powyższym kodzie:
  327. - `saveUserData(UserData userData)` zapisuje nowy obiekt UserData do bazy danych.
  328. - `updateUser(UserData userData)` aktualizuje istniejący obiekt UserData w bazie danych.
  329. - `deleteUser(Long id)` usuwa obiekt UserData z bazy danych na podstawie jego id.
  330. - `getUser(Long id)` pobiera obiekt UserData z bazy danych na podstawie jego id.
  331.  
  332. Do poprawnego działania powyższego kodu, potrzebujesz klasy `HibernateUtil`, która dostarcza obiekt `SessionFactory`. `SessionFactory` jest używany do otwierania nowych sesji Hibernate. Poniżej znajduje się przykładowa klasa `HibernateUtil`:
  333.  
  334. ```java
  335. import org.hibernate.HibernateException;
  336. import org.hibernate.SessionFactory;
  337. import org.hibernate.cfg.Configuration;
  338.  
  339. public class HibernateUtil {
  340. private static final SessionFactory sessionFactory;
  341.  
  342. static {
  343. try {
  344. sessionFactory = new Configuration().configure().buildSessionFactory();
  345. } catch (HibernateException ex) {
  346. throw new ExceptionInInitializerError(ex);
  347. }
  348. }
  349.  
  350. public static SessionFactory getSessionFactory() {
  351. return sessionFactory;
  352. }
  353. }
  354. ```
  355.  
  356. Zauważ, że powyższe metody DAO są niskopoziomowe i nie zapewniają żadnej logiki biznesowej. W prawdziwym projek
  357.  
  358. Przykładowe metody DAO mogą wyglądać tak:
  359.  
  360. ```java
  361. import org.hibernate.Session;
  362. import org.hibernate.Transaction;
  363.  
  364. public class UserDataDao {
  365.  
  366. public void saveUserData(UserData userData) {
  367. Transaction transaction = null;
  368. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  369. // start a transaction
  370. transaction = session.beginTransaction();
  371. // save the user data object
  372. session.save(userData);
  373. // commit transaction
  374. transaction.commit();
  375. } catch (Exception e) {
  376. if (transaction != null) {
  377. transaction.rollback();
  378. }
  379. e.printStackTrace();
  380. }
  381. }
  382.  
  383. public void updateUser(UserData userData) {
  384. Transaction transaction = null;
  385. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  386. // start a transaction
  387. transaction = session.beginTransaction();
  388. // update the user data object
  389. session.update(userData);
  390. // commit transaction
  391. transaction.commit();
  392. } catch (Exception e) {
  393. if (transaction != null) {
  394. transaction.rollback();
  395. }
  396. e.printStackTrace();
  397. }
  398. }
  399.  
  400. public void deleteUser(Long id) {
  401. Transaction transaction = null;
  402. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  403. // start a transaction
  404. transaction = session.beginTransaction();
  405.  
  406. // Delete a user data object
  407. UserData userData = session.get(UserData.class, id);
  408. if (userData != null) {
  409. session.delete(userData);
  410. System.out.println("User data is deleted");
  411. }
  412.  
  413. // commit transaction
  414. transaction.commit();
  415. } catch (Exception e) {
  416. if (transaction != null) {
  417. transaction.rollback();
  418. }
  419. e.printStackTrace();
  420. }
  421. }
  422.  
  423. public UserData getUser(Long id) {
  424.  
  425. Transaction transaction = null;
  426. UserData userData = null;
  427. try (Session session = HibernateUtil.getSessionFactory().openSession()) {
  428. // start a transaction
  429. transaction = session.beginTransaction();
  430. // get an user data object
  431. userData = session.get(UserData.class, id);
  432. // commit transaction
  433. transaction.commit();
  434. } catch (Exception e) {
  435. if (transaction != null) {
  436. transaction.rollback();
  437. }
  438. e.printStackTrace();
  439. }
  440. return userData;
  441. }
  442. }
  443. ```
  444.  
  445. W powyższym kodzie:
  446. - `saveUserData(UserData userData)` zapisuje nowy obiekt UserData do bazy danych.
  447. - `updateUser(UserData userData)` aktualizuje istniejący obiekt UserData w bazie danych.
  448. - `deleteUser(Long id)` usuwa obiekt UserData z bazy danych na podstawie jego id.
  449. - `getUser(Long id)` pobiera obiekt UserData z bazy danych na podstawie jego id.
  450.  
  451. Do poprawnego działania powyższego kodu, potrzebujesz klasy `HibernateUtil`, która dostarcza obiekt `SessionFactory`. `SessionFactory` jest używany do otwierania nowych sesji Hibernate. Poniżej znajduje się przykładowa klasa `HibernateUtil`:
  452.  
  453. ```java
  454. import org.hibernate.HibernateException;
  455. import org.hibernate.SessionFactory;
  456. import org.hibernate.cfg.Configuration;
  457.  
  458. public class HibernateUtil {
  459. private static final SessionFactory sessionFactory;
  460.  
  461. static {
  462. try {
  463. sessionFactory = new Configuration().configure().buildSessionFactory();
  464. } catch (HibernateException ex) {
  465. throw new ExceptionInInitializerError(ex);
  466. }
  467. }
  468.  
  469. public static SessionFactory getSessionFactory() {
  470. return sessionFactory;
  471. }
  472. }
  473. ```
  474.  
  475. Zauważ, że powyższe metody DAO są niskopoziomowe i nie zapewniają żadnej logiki biznesowej. W praw
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!