საგაზაფხულო JDBC template
მიმოხილვა: როგორც ყველამ ვიცით, რომ გაზაფხულზე ფარგლებში გახდა განუყოფელი ნაწილია თანამედროვე ჯავის დაფუძნებული განაცხადის განვითარების. გაზაფხულზე ჩარჩო ეფექტურად მოახერხა აღებას ყველა დეპარტამენტი ჯავის განვითარების მსოფლიოში. JDBC template გაზაფხულზე გამოიყენება ყველაზე გაზაფხულის დაფუძნებული Jee განაცხადების კომუნიკაცია მონაცემთა ბაზა.
ამ მუხლის მე ვისაუბრებთ იმაზე, თუ როგორ, რათა შეამოწმონ რელატიური მონაცემთა ბაზის გამოყენებით JDBC template გაზაფხულზე.
შესავალი: ჩვენ ყველამ ვიცით, რომ მნიშვნელოვანია რელაციური მონაცემთა ბაზის საწარმო განაცხადის განვითარების. გაზაფხულის ერთი ფართოდ გამოიყენება ფარგლებში ჯავის დაფუძნებული საწარმოს განაცხადის განვითარების. საგაზაფხულო აქვს სხვადასხვა მოდულები როგორიცაა ORM, უსაფრთხოების, გარიგების, JPS, JMS ა.შ. მხარდასაჭერად სჭირდება საწარმოს განაცხადის განვითარების. როგორც გაზაფხულზე უზრუნველყოფს ხელმისაწვდომი კომპონენტების დანამატი, თანამედროვე მიდგომა საწარმოს Java განაცხადის განვითარების იყენებს თვისებები ინტენსიურად. შედეგად განვითარების ბევრად უფრო სწრაფად და ეფექტური. საგაზაფხულო უზრუნველყოფს მარტივი მიდგომა გაუმკლავდეს მონაცემთა ბაზა საქმიანობის ვიცი, როგორც გაზაფხულზე JDBC template.
ნაკლოვანებები სტანდარტული JDBC API: სტანდარტული JDBC API აქვს შემდეგი ნაკლოვანებები.
- გარდა შესრულებაში მთავარი შეკითხვის, თქვენ უნდა დაწეროთ ბევრი კოდი გაუმკლავდეს შესრულების გარემოს საკითხებზე, როგორიცაა შექმნაში დაკავშირებით, განცხადება, resultset ა.შ..
- უნდა გაუმკლავდეს გამონაკლისი გატარება კოდი ცალ-ცალკე.
- უნდა გაუმკლავდეს ოპერაციული საკითხები.
უპირატესობები გაზაფხულზე JDBC template: საგაზაფხულო JDBC template აქვს შემდეგი უპირატესობები შედარებით ნორმალური მიდგომა სტანდარტული JDBC.
- დასუფთავების გამოყენებული რესურსების კეთდება ავტომატურად გაზაფხულზე JDBC template. ასე რომ, დეველოპერები არ გჭირდებათ შეწუხება გათავისუფლების რესურსები. აქედან გამომდინარე, ეს ხელს უშლის მეხსიერების ტბები.
- საგაზაფხულო JDBC template ამუშავებს გამონაკლისი და შეცდომები უფრო ეფექტური გზა. ეს აკონვერტებს JDBC SQLExceptions შევიდა RuntimeExceptions, ამიტომ დეველოპერები შეუძლია ეს უფრო მოქნილი გზა.
- გაზაფხულზე JDBC თარგი ასევე აკონვერტებს გამყიდველი კონკრეტული შეცდომების უკეთესი მნიშვნელოვანი გაგზავნა. ასე რომ, handlings იმ შეცდომების უფრო ეფექტური.
ვიწყებთ:
In this document, მოდით გამოვიყენოთ Gradle როგორც build ინსტრუმენტი აშენება ჩვენი განცხადება. მოდით, დავიწყოთ მარტივი პროგრამა გამოიყენება შესანახად და ვიღებ დეტალები თანამშრომლებს ერთად მათი სამსახურების ორგანიზაცია. ჩვენი მაგალითი, ჩვენ გვაქვს შემდეგი ატრიბუტები თანამშრომელი ობიექტი:-
- თანამშრომელთა Id
- თანამშრომელთა სახელი
- თანამშრომელთა მომხმარებლის სახელი
- თანამშრომელთა გვარი
- თანამშრომელთა დეპარტამენტის Id
და დეპარტამენტის ობიექტი აქვს შემდეგი ატრიბუტები:-
- დეპარტამენტის Id
- დეპარტამენტის სახელწოდება
ახლა მოდით შევქმნათ java ობიექტი, რომელიც გამოყენებული იქნება კომუნიკაცია მონაცემთა ბაზაში. ჩვენი POJO კლასების ამ ორი სუბიექტის ჩამოთვლილია როგორც ქვეშ:
Listing1: Sample გვიჩვენებს თანამშრომელი კლასი
[Code]
package com.home.springjdbc.objects;
საჯარო კლასის Employee {
// თანამშრომელი Id
შეტყობინების სიმებიანი empId;
// თანამშრომლის სახელი
შეტყობინების სიმებიანი empFName;
// თანამშრომელი შუა სახელი
შეტყობინების სიმებიანი empMName;
// თანამშრომლის გვარი
შეტყობინების სიმებიანი empLName;
// თანამშრომელი დეპარტამენტის Id
შეტყობინების სიმებიანი empDeptId;
საჯარო Employee ( სიმებიანი empId, სიმებიანი empFName, სიმებიანი empMName,
სიმებიანი empLName, სიმებიანი empDeptId ) {
სუპერ();
ამ.EmpID = EmpID;
ამ.რეკომენდირებული რეკომენდირებული name = სახელი;
ამ.empMName = empMName;
ამ.empLName = empLName;
ამ.empDeptId = empDeptId;
}
/**
* @დაბრუნების empId
*/
საჯარო string getEmpId () {
return EmpID;
}
/**
* @param EmpID
* empId მითითებული
*/
საჯარო ცნოს setEmpId ( სიმებიანი empId ) {
ამ.EmpID = EmpID;
}
/**
* @დაბრუნების empFName
*/
საჯარო string getEmpFName () {
return რეკომენდირებული სახელი;
}
/**
* @param რეკომენდირებული სახელი
* empFName მითითებული
*/
საჯარო ცნოს setEmpFName ( სიმებიანი empFName ) {
ამ.რეკომენდირებული რეკომენდირებული name = სახელი;
}
/**
* @დაბრუნების empMName
*/
საჯარო string getEmpMName () {
return empMName;
}
/**
* @param empMName
* empMName მითითებული
*/
საჯარო ცნოს setEmpMName ( სიმებიანი empMName) {
ამ.empMName = empMName;
}
/**
* @დაბრუნების empLName
*/
საჯარო string getEmpLName () {
return empLName;
}
/**
* @param empLName
* empLName მითითებული
*/
საჯარო ცნოს setEmpLName ( სიმებიანი empLName) {
ამ.empLName = empLName;
}
/**
* @დაბრუნების empDeptId
*/
საჯარო string getEmpDeptId () {
return empDeptId;
}
/**
* @param empDeptId
* empDeptId მითითებული
*/
საჯარო ცნოს setEmpDeptId ( სიმებიანი empDeptId ) {
ამ.empDeptId = empDeptId;
}
/*
* ( არასამთავრობო-javadoc )
*
* @see java.lang.Object # toString ()
*/
@ Override
საჯარო სიმებიანი toString () {
return “Employee [ EmpID =” + EmpID + “, რეკომენდირებული name =” + რეკომენდირებული სახელი
+ “, empMName =” + empMName + “, empLName =” + empLName
+ “, empDeptId =” + empDeptId + “]”;
}
}
[/Code]
Listing2: Sample ნაჩვენებია დეპარტამენტის კლასი
[Code]
package com.home.springjdbc.objects;
საჯარო კლასის დეპარტამენტის {
// დეპარტამენტის Id
შეტყობინების სიმებიანი deptId;
// დეპარტამენტის სახელი
შეტყობინების სიმებიანი deptName;
საჯარო დეპარტამენტის ( სიმებიანი deptId, სიმებიანი deptName) {
სუპერ ();
ამ.deptId = deptId;
ამ.deptName = deptName;
}
/**
* @დაბრუნების deptId
*/
საჯარო სიმებიანი getDeptId () {
return deptId;
}
/**
* @param deptId
* deptId მითითებული
*/
საჯარო ცნოს setDeptId ( სიმებიანი deptId ) {
ამ.deptId = deptId;
}
/**
* @დაბრუნების deptName
*/
საჯარო სიმებიანი getDeptName () {
return deptName;
}
/**
* @param deptName
* deptName მითითებული
*/
საჯარო ცნოს setDeptName ( სიმებიანი deptName ) {
ამ.deptName = deptName;
}
/*
* (არასამთავრობო-javadoc)
*
* @see java.lang.Object # toString()
*/
@ Override
საჯარო სიმებიანი toString () {
return “დეპარტამენტის [ deptId =” + deptId + “, deptName =” + deptName + “]”;
}
}
[/Code]
საგაზაფხულო უზრუნველყოფს template კლასის ცნობილია, როგორც JdbcTemplate. ეს კლასი არის პასუხისმგებელი ურთიერთობისას SQL რელატიური მონაცემთა ბაზები და JDBC. ტრადიციული მიდგომა მაქსიმუმ JDBC კოდი ოკუპირებულია გატარება კავშირი მართვა, რესურსი შეძენის, გარდა გატარება, და ზოგადად შეცდომების შემოწმება, რომელიც არის უადგილო კონტექსტში, რასაც ჩვენ ვცდილობთ მივაღწიოთ. JdbcTemplate ზრუნავს ყველა ეს ყველაფერი და, როგორც დეველოპერი უნდა ფოკუსირება მხოლოდ ბიზნეს ლოგიკა. ნიმუში განხორციელების თარგი კლასის ნაჩვენებია ქვეშ -
Listing3: Sample ნაჩვენებია განხორციელების JDBC template
[Code]
package com.home.springjdbc.dao;
იმპორტი java.sql.Driver;
იმპორტი java.sql.ResultSet;
იმპორტი java.sql.SQLException;
იმპორტი java.util.List;
იმპორტი org.springframework.jdbc.core.JdbcTemplate;
იმპორტი org.springframework.jdbc.core.RowMapper;
იმპორტი org.springframework.jdbc.datasource.SimpleDriverDataSource;
იმპორტი com.home.springjdbc.objects.Employee;
საჯარო კლასის EmployeeDAO {
საჯარო სტატიკური ცნოს მთავარი ( სიმებიანი args[] ) {
// მარტივი DS ტესტი (არა წარმოების!)
SimpleDriverDataSource DataSource = ახალი SimpleDriverDataSource();
dataSource.setDriverClass((კლასი<? ვრცელდება Driver>) org.h2.Driver.კლასის);
dataSource.setUsername( “მისი” );
dataSource.setUrl( “jdbc:h2:Mem” );
dataSource.setPassword( “” );
JdbcTemplate JdbcTemplate = ახალი JdbcTemplate(dataSource);
სისტემები.გარეთ.println( “შექმნის მაგიდები” );
jdbcTemplate.execute( “ვარდნა მაგიდა თანამშრომლებს, თუ არსებობს” );
jdbcTemplate.execute( “შევქმნათ ცხრილი თანამშრომლები(”
+ “id varchar(25), , FIRST_NAME varchar(255), middle_name varchar(255), LAST_NAME varchar(255), deptId varchar(25))”);
სიმებიანი[] ჩანაწერი = “E001 Dean ანდრია რობერტსი D25; E002 Jeff Longman Dean D42; E003 Erin Nancy Kirkland d66;”.გაყოფილი(“;”);
ამისთვის ( სიმებიანი singleRecord : ჩანაწერები ) {
სიმებიანი [] კოლები = singleRecord.split(” “);
სისტემები.გარეთ.printf( ” დამატება თანამშრომელი რეკორდი% s% s% s% s% s n”,სვეტი[0], სვეტი[1], სვეტი[2], სვეტი[3], სვეტი[4]);
jdbcTemplate.update(“INSERT INTO თანამშრომლები(id, სახელი, მეორე სახელი, გვარი, deptId) ღირებულებები(?,?,?,?,?)”,სვეტი[0], სვეტი[1], სვეტი[2], სვეტი[3], სვეტი[4]);
}
სისტემები.გარეთ.println ( ” Querying for customer records where first_name = ‘Erin’:” );
სია<Employee> შედეგები = jdbcTemplate.query(
“select * თანამშრომლები, სადაც, FIRST_NAME = ?”,
ახალი ობიექტის[] { “Erin” }, ახალი RowMapper<Employee>() {
@ Override
საჯარო თანამშრომელთა mapRow(ResultSet rs, int ROWNUM)
ისვრის SQLException {
return ახალი Employee(rs.getString(“id”),
rs.getString(“სახელი”), rs.getString(“მეორე სახელი”),
rs.getString(“გვარი”), rs.getString(“deptId”));
}
});
ამისთვის (თანამშრომელთა თანამშრომელი : შედეგები) {
სისტემები.გარეთ.println(თანამშრომელი);
}
}
}
[/Code]
ზემოთ მაგალითად, ჩვენ შეიქმნა JDBC მონაცემთა წყარო გამოყენებით SimpleDriverDataSource გაზაფხულიდან. ჩვენ მაშინ გამოიყენოს ეს მონაცემთა წყარო მშენებლობა JDBCTemplate მაგალითად. მას შემდეგ, რაც JDBCTemplate კლასი შექმნილია, ჩვენ შეგვიძლია ადვილად დაიწყოს მოუწოდებდა მონაცემთა ბაზაში. First, ჩვენ ვქმნით მაგიდაზე გამოყენებით შეასრულოს მეთოდი თარგი. მაშინ ჩვენ ჩადეთ რამდენიმე ჩანაწერი გამოყენებით განახლება მეთოდი თარგი. და ბოლოს, ჩვენ ვიყენებთ შეკითხვის მეთოდი მოიტანონ ჩანაწერები ჩვენი არჩევანი. ჩვენს მაგალითში ჩვენ არ გამოიყენება მარტივი შეკითხვის მოიტანონ ჩანაწერი თანამშრომელი მაგიდა. მაგრამ, როგორც თითო ჩვენი დიზაინი, ჩვენ ვხედავთ, რომ თანამშრომელი მაგიდაზე აქვს ურთიერთობის დეპარტამენტის მაგიდა მეშვეობით სვეტი - deptId. ასე რომ, ჩვენ ასევე შეგიძლიათ გამოიყენოთ იგივე კოდი მოიტანონ ჩანაწერები უერთდება ამ ორ მაგიდას. უბრალოდ ჩვენ უნდა შეიცვალოს შეკითხვის დააყენოს შეუერთდება. აღნიშნული კოდი შეიძლება შეცვლილია როგორც ქვეშ -
Listing4: Sample გვიჩვენებს შეცვლილია შეკითხვაზე
[Code]
სია<Employee> შედეგები = jdbcTemplate.query(
“აირჩიეთ emp.first_name, emp.middle _name, emp.last _name, dept.dept_Name თანამშრომლები emp, დეპარტამენტის ვალი, სადაც emp.first_name = ?”,
ახალი ობიექტის[] { “Erin” }, ახალი RowMapper<Employee>() {
@ Override
საჯარო EmployeeDtls mapRow(ResultSet rs, int ROWNUM)
ისვრის SQLException {
return ახალი Employee( rs.getString(“სახელი”),
rs.getString(“მეორე სახელი”),
rs.getString(“გვარი”),
rs.getString(“dept_Name “));
}
});
ამისთვის (EmployeeDtls employeeDtl : შედეგები) {
სისტემები.გარეთ.println(employeeDtl);
}
[/Code]
იმისათვის, რომ შეასრულოს ეს ჩვენ უნდა ჰქონდეს მეორე POJO კლასის EmployeeDtls ქვეშ -
Listing5: Sample გვიჩვენებს POJO კლასის EmployeeDtls
[Code]
package com.home.springjdbc.objects;
საჯარო კლასის EmployeeDtls {
// თანამშრომლის სახელი
შეტყობინების სიმებიანი empFName;
// თანამშრომელი შუა სახელი
შეტყობინების სიმებიანი empMName;
// თანამშრომლის გვარი
შეტყობინების სიმებიანი empLName;
// დეპარტამენტის სახელი
შეტყობინების სიმებიანი deptName;
/**
* @param რეკომენდირებული სახელი
* @param empMName
* @param empLName
* @param deptName
*/
საჯარო EmployeeDtls(სიმებიანი empFName, სიმებიანი empMName, სიმებიანი empLName,
სიმებიანი deptName) {
სუპერ();
ამ.რეკომენდირებული რეკომენდირებული name = სახელი;
ამ.empMName = empMName;
ამ.empLName = empLName;
ამ.deptName = deptName;
}
/*
* (არასამთავრობო-javadoc)
*
* @see java.lang.Object # toString()
*/
@ Override
საჯარო სიმებიანი toString() {
return “EmployeeDtls [რეკომენდირებული name =” + რეკომენდირებული სახელი + “, empMName =” + empMName
+ “, empLName =” + empLName + “, deptName =” + deptName + “]”;
}
/**
* @დაბრუნების empFName
*/
საჯარო string getEmpFName() {
return რეკომენდირებული სახელი;
}
/**
* @param რეკომენდირებული სახელი
* empFName მითითებული
*/
საჯარო ცნოს setEmpFName(სიმებიანი empFName) {
ამ.რეკომენდირებული რეკომენდირებული name = სახელი;
}
/**
* @დაბრუნების empMName
*/
საჯარო string getEmpMName() {
return empMName;
}
/**
* @param empMName
* empMName მითითებული
*/
საჯარო ცნოს setEmpMName(სიმებიანი empMName) {
ამ.empMName = empMName;
}
/**
* @დაბრუნების empLName
*/
საჯარო string getEmpLName() {
return empLName;
}
/**
* @param empLName
* empLName მითითებული
*/
საჯარო ცნოს setEmpLName(სიმებიანი empLName) {
ამ.empLName = empLName;
}
/**
* @დაბრუნების deptName
*/
საჯარო სიმებიანი getDeptName() {
return deptName;
}
/**
* @param deptName
* deptName მითითებული
*/
საჯარო ცნოს setDeptName(სიმებიანი deptName) {
ამ.deptName = deptName;
}
}
[/Code]
Summary: ასე რომ, ამ სტატიაში ჩვენ ვნახეთ, როგორ გაზაფხულზე JDBC თარგი შეიძლება გამოყენებულ იქნას ჯავა სტანდარტული და საწარმოს განაცხადების. ჩვენ ასევე განვიხილეთ უპირატესობა ამ მიდგომის და როგორ შეიძლება, რომ განვითარების ბევრად უფრო სწრაფად, ვიდრე სტანდარტული JDBC განვითარების.
მოდით შევაჯამოთ ჩვენი დისკუსიის სახით შემდეგ ტყვია რაოდენობა -
- Spring გახდა განუყოფელი ნაწილია თანამედროვე Java დაფუძნებული საწარმოს განაცხადის განვითარება გარემოს.
- საგაზაფხულო აქვს სხვადასხვა სექციები, აქედან, JDBC template არის მნიშვნელოვანი ნაწილი.
- საგაზაფხულო JDBC template აადვილებს განვითარების აღების დატვირთვა რესურსების შეძენის, კავშირი მართვა, გარდა გატარება, და ზოგადად შეცდომა შემოწმების. ჩვენ, როგორც დეველოპერი უბრალოდ უნდა კონცენტრირება რთული ბიზნეს სცენარი.
