iBATIS - त्वरित गाइड

iBATIS एक दृढ़ता ढांचा है जो SQL डेटाबेस और ऑब्जेक्ट्स के बीच जावा, .NET, और रूबी के बीच मैपिंग को स्वचालित करता है। XML कॉन्फ़िगरेशन फ़ाइलों में SQL कथनों की पैकेजिंग करके मैपिंग को एप्लिकेशन लॉजिक से हटा दिया जाता है।

iBATIS POJOs (प्लेन ओल्ड जावा ऑब्जेक्ट्स) को बनाए रखने के लिए एक हल्का ढांचा और दृढ़ता वाला एपीआई अच्छा है।

iBATIS वह है जो डेटा मैपर के रूप में जाना जाता है और वर्ग गुणों और डेटाबेस तालिका के कॉलम के बीच मापदंडों और परिणामों की मैपिंग का ख्याल रखता है।

IBATIS और अन्य दृढ़ता फ्रेमवर्क जैसे कि Hibernate के बीच एक महत्वपूर्ण अंतर यह है कि iBATIS SQL के उपयोग पर जोर देता है, जबकि अन्य चौखटे आमतौर पर एक कस्टम क्वेरी भाषा का उपयोग करते हैं जैसे कि Hibernate क्वेरी भाषा (HQL या एंटरप्राइज़ JavaBeans Query Language (EJB QL))।

iBATIS डिजाइन दर्शन

iBATIS निम्नलिखित डिजाइन दर्शन के साथ आता है -

  • Simplicity − iBATIS को आज उपलब्ध सबसे सरल दृढ़ता ढांचे में से एक माना जाता है।

  • Fast Development − iBATIS हाइपर-फास्ट विकास की सुविधा के लिए यह सब कर सकता है।

  • Portability − iBATIS को Microsoft .NET के लिए लगभग किसी भी भाषा या प्लेटफ़ॉर्म जैसे जावा, रूबी और C # के लिए लागू किया जा सकता है।

  • Independent Interfaces − iBATIS डेटाबेस-स्वतंत्र इंटरफेस और एपीआई प्रदान करता है जो बाकी एप्लिकेशन को किसी भी दृढ़ता से संबंधित संसाधनों से स्वतंत्र रहने में मदद करता है।

  • Open source − iBATIS स्वतंत्र और एक खुला स्रोत सॉफ्टवेयर है।

IBATIS के लाभ

iBATIS निम्नलिखित लाभ प्रदान करता है -

  • Supports stored procedures − iBATIS संग्रहीत कार्यविधियों के रूप में SQL को एन्क्रिप्ट करता है ताकि व्यापार तर्क डेटाबेस से बाहर रखा जाए, और एप्लिकेशन को तैनात करना और परीक्षण करना आसान हो, और अधिक पोर्टेबल हो।

  • Supports inline SQL − कोई precompiler की आवश्यकता नहीं है, और आपके पास SQL ​​की सभी विशेषताओं तक पूर्ण पहुंच है।

  • Supports dynamic SQL − iBATIS मापदंडों के आधार पर गतिशील रूप से SQL प्रश्नों के निर्माण के लिए सुविधाएँ प्रदान करता है।

  • Supports O/RM − iBATIS O / RM टूल के समान कई विशेषताओं का समर्थन करता है, जैसे आलसी लोडिंग, फ़िशिंग, कैशिंग, रनटाइम कोड जेनरेशन, और इनहेरिटेंस

डेटाबेस उन्मुख अनुप्रयोग विकसित करते समय iBATIS JAVA प्रोग्रामिंग भाषा का उपयोग करता है। आगे बढ़ने से पहले, सुनिश्चित करें कि आप प्रक्रियात्मक और ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग की मूल बातें समझते हैं - नियंत्रण संरचनाएं, डेटा संरचनाएं और चर, कक्षाएं, ऑब्जेक्ट्स आदि।

जावा को विस्तार से समझने के लिए आप हमारे जावा ट्यूटोरियल के माध्यम से जा सकते हैं ।

वास्तविक विकास कार्य शुरू करने से पहले आपको iBATIS के लिए उचित वातावरण स्थापित करना होगा। यह अध्याय बताता है कि iBATIS के लिए काम करने का माहौल कैसे सेट किया जाए।

iBATIS इंस्टॉलेशन

अपने लिनक्स मशीन पर iBATIS स्थापित करने के लिए निम्नलिखित सरल चरणों का पालन करें -

  • डाउनलोड iBATIS से iBATIS का नवीनतम संस्करण डाउनलोड करें ।

  • बंडल से .jar फ़ाइल को निकालने के लिए डाउनलोड की गई फ़ाइल को अनज़िप करें और उन्हें उपयुक्त लिबरी डायरेक्टरी में रखें।

  • निकाले गए .jar फ़ाइल (s) को उचित रूप से PATH और CLASSPATH चर सेट करें।

$ unzip ibatis-2.3.4.726.zip inflating: META-INF/MANIFEST.MF creating: doc/ creating: lib/ creating: simple_example/ creating: simple_example/com/ creating: simple_example/com/mydomain/ creating: simple_example/com/mydomain/data/ creating: simple_example/com/mydomain/domain/ creating: src/ inflating: doc/dev-javadoc.zip inflating: doc/user-javadoc.zip inflating: jar-dependencies.txt inflating: lib/ibatis-2.3.4.726.jar inflating: license.txt inflating: notice.txt inflating: release.txt $pwd
/var/home/ibatis
$set PATH=$PATH:/var/home/ibatis/
$set CLASSPATH=$CLASSPATH:/var/home/ibatis\
      /lib/ibatis-2.3.4.726.jar

डेटाबेस सेटअप

निम्नलिखित सिंटैक्स का उपयोग करके किसी भी MySQL डेटाबेस में एक EMPLOYEE तालिका बनाएँ -

mysql> CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

SqlMapConfig.xml बनाएं

निम्नलिखित पर विचार करें -

  • हम डेटाबेस तक पहुँचने के लिए JDBC का उपयोग करने जा रहे हैं testdb।

  • MySQL के लिए JDBC ड्राइवर "com.mysql.jdbc.Driver" है।

  • कनेक्शन URL "jdbc: mysql: // localhost: 3306 / testdb" है।

  • हम क्रमशः "रूट" और "रूट" के रूप में उपयोगकर्ता नाम और पासवर्ड का उपयोग करेंगे।

  • सभी कार्यों के लिए हमारी एसक्यूएल स्टेटमेंट मैपिंग का वर्णन "Employee.xml" में किया जाएगा।

उपरोक्त मान्यताओं के आधार पर, हमें नाम के साथ एक XML कॉन्फ़िगरेशन फ़ाइल बनानी होगी SqlMapConfig.xmlनिम्नलिखित सामग्री के साथ। यह वह जगह है जहाँ आपको iBatis के लिए आवश्यक सभी विन्यास प्रदान करने की आवश्यकता है -

यह महत्वपूर्ण है कि SqlMapConfig.xml और Employee.xml दोनों फाइलें क्लास पाथ में मौजूद होनी चाहिए। अभी के लिए, हम Employee.xml फ़ाइल को खाली रखेंगे और हम इसकी सामग्री को बाद के अध्यायों में शामिल करेंगे।

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMapConfig PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">

<sqlMapConfig>
   <settings useStatementNamespaces="true"/>
	
   <transactionManager type="JDBC">
      <dataSource type="SIMPLE">
		
         <property name="JDBC.Driver" value="com.mysql.jdbc.Driver"/>
         <property name="JDBC.ConnectionURL" value="jdbc:mysql://localhost:3306/testdb"/>
         <property name="JDBC.Username" value="root"/>
         <property name="JDBC.Password" value="root"/>
			
      </dataSource>
   </transactionManager>
	
   <sqlMap resource="Employee.xml"/> 
</sqlMapConfig>

आप निम्नलिखित वैकल्पिक गुणों को SqlMapConfig.xml फ़ाइल का उपयोग करके सेट कर सकते हैं -

<property name="JDBC.AutoCommit" value="true"/>
<property name="Pool.MaximumActiveConnections" value="10"/>
<property name="Pool.MaximumIdleConnections" value="5"/>
<property name="Pool.MaximumCheckoutTime" value="150000"/> 
<property name="Pool.MaximumTimeToWait" value="500"/> 
<property name="Pool.PingQuery" value="select 1 from Employee"/> 
<property name="Pool.PingEnabled" value="false"/>

IBATIS का उपयोग करके कोई भी क्रिएट, रीड, अपडेट और डिलीट (CRUD) ऑपरेशन करने के लिए, आपको टेबल के अनुरूप प्लेन ओल्ड जावा ऑब्जेक्ट (POJO) क्लास बनाना होगा। यह वर्ग उन वस्तुओं का वर्णन करता है जो डेटाबेस तालिका पंक्तियों को "मॉडल" करेंगे।

POJO वर्ग वांछित संचालन करने के लिए आवश्यक सभी तरीकों के लिए कार्यान्वयन होगा।

मान लें कि हमारे पास MySQL में निम्न EMPLOYEE तालिका है -

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

कर्मचारी POJO वर्ग

हम Employee.java फ़ाइल में निम्नानुसार एक कर्मचारी वर्ग बनाएंगे -

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   /* Define constructors for the Employee class. */
   public Employee() {}
  
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }
} /* End of Employee */

आप तालिका में अलग-अलग फ़ील्ड सेट करने के तरीकों को परिभाषित कर सकते हैं। अगला अध्याय बताता है कि व्यक्तिगत क्षेत्रों के मूल्यों को कैसे प्राप्त किया जाए।

Employee.xml फ़ाइल

IBATIS का उपयोग करते हुए SQL मैपिंग स्टेटमेंट को परिभाषित करने के लिए, हम <Insert> टैग का उपयोग करेंगे और इस टैग परिभाषा के अंदर, हम एक "id" को परिभाषित करेंगे जिसका उपयोग डेटाबेस में SQL INSERT क्वेरी को निष्पादित करने के लिए IbatisInsert.java फ़ाइल में किया जाएगा।

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee"> 

   <insert id="insert" parameterClass="Employee">
      insert into EMPLOYEE(first_name, last_name, salary)
      values (#first_name#, #last_name#, #salary#)

      <selectKey resultClass="int" keyProperty="id">
         select last_insert_id() as id
      </selectKey>
   </insert> 

</sqlMap>

यहाँ parameterClass −स्ट्रिंग, इंट, फ्लोट, डबल , या आवश्यकता के आधार पर किसी भी क्लास ऑब्जेक्ट के रूप में मान ले सकता है । इस उदाहरण में, हम SqlMap वर्ग की सम्मिलित विधि को कॉल करते समय एक पैरामीटर के रूप में कर्मचारी वस्तु को पारित करेंगे ।

यदि आपकी डेटाबेस तालिका एक पहचान, AUTO_INCREMENT, या सीरियल कॉलम का उपयोग करती है या आपने एक SEQUENCE / जनरेटर को परिभाषित किया है, तो आप डेटाबेस-जनित मान का उपयोग या वापस करने के लिए <select> विवरण में <selectKey> तत्व का उपयोग कर सकते हैं।

IbatisInsert.java फ़ाइल

इस फ़ाइल में कर्मचारी तालिका में रिकॉर्ड सम्मिलित करने के लिए आवेदन स्तर तर्क होगा -

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisInsert{
   public static void main(String[] args)throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);

      /* This would insert one record in Employee table. */
      System.out.println("Going to insert record.....");
      Employee em = new Employee("Zara", "Ali", 5000);

      smc.insert("Employee.insert", em);

      System.out.println("Record Inserted Successfully ");
   }
}

संकलन और भागो

उपर्युक्त सॉफ्टवेयर को संकलित करने और चलाने के लिए यहां चरण दिए गए हैं। सुनिश्चित करें कि आपने संकलन और निष्पादन के लिए आगे बढ़ने से पहले PATH और CLASSPATH को उचित रूप से सेट किया है।

  • जैसा कि ऊपर दिखाया गया है Employee.xml बनाएं।
  • जैसा कि ऊपर दिखाया गया है, Employee.java बनाएं और इसे संकलित करें।
  • जैसा कि ऊपर दिखाया गया है और इसे संकलित करें।
  • कार्यक्रम को चलाने के लिए आईबेटिसइंटरटेट बाइनरी निष्पादित करें।

आपको निम्न परिणाम मिलेगा, और EMPLOYEE तालिका में एक रिकॉर्ड बनाया जाएगा।

$java IbatisInsert
Going to insert record.....
Record Inserted Successfully

यदि आप EMPLOYEE तालिका की जांच करते हैं, तो उसे निम्न परिणाम प्रदर्शित करना चाहिए -

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
|  1 | Zara       | Ali       |   5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)

हमने चर्चा की, आखिरी अध्याय में, iBATIS का उपयोग करके टेबल पर क्रिएट ऑपरेशन कैसे करें। यह अध्याय बताता है कि iBATIS का उपयोग करके तालिका कैसे पढ़ें।

हमारे पास MySQL में निम्न EMPLOYEE तालिका है -

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

इस तालिका में केवल एक रिकॉर्ड निम्नानुसार है -

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
|  1 | Zara       | Ali       |   5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)

कर्मचारी POJO वर्ग

रीड ऑपरेशन करने के लिए, हम Employee.java में कर्मचारी वर्ग को संशोधित करेंगे -

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   /* Define constructors for the Employee class. */
   public Employee() {}
  
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }

   /* Here are the method definitions */
   public int getId() {
      return id;
   }
	
   public String getFirstName() {
      return first_name;
   }
	
   public String getLastName() {
      return last_name;
   }
	
   public int getSalary() {
      return salary;
   }
	
} /* End of Employee */

Employee.xml फ़ाइल

IBATIS का उपयोग करते हुए SQL मैपिंग स्टेटमेंट को परिभाषित करने के लिए, हम Employee.xml फ़ाइल में <select> टैग जोड़ेंगे और इस टैग परिभाषा के अंदर, हम एक "id" को परिभाषित करेंगे जिसका उपयोग डेटाबेस पर SQL SELECT क्वेरी को निष्पादित करने के लिए IbatisRead.java फ़ाइल में किया जाएगा।

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee">

   <insert id="insert" parameterClass="Employee">
      INSERT INTO EMPLOYEE(first_name, last_name, salary)
      values (#first_name#, #last_name#, #salary#)

      <selectKey resultClass="int" keyProperty="id">
         select last_insert_id() as id
      </selectKey>
   </insert>
	
   <select id="getAll" resultClass="Employee">
      SELECT * FROM EMPLOYEE
   </select>
	
</sqlMap>

यहां हमने SQL SELECT स्टेटमेंट के साथ WHERE क्लॉज का उपयोग नहीं किया। हम अगले अध्याय में प्रदर्शित करेंगे, कि आप SELECT स्टेटमेंट के साथ WHERE क्लॉज का उपयोग कैसे कर सकते हैं और आप उस WHO क्लॉज के मानों को कैसे पास कर सकते हैं।

IbatisRead.java फ़ाइल

इस फ़ाइल में कर्मचारी स्तर से रिकॉर्ड पढ़ने के लिए आवेदन स्तर तर्क है -

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisRead{
   public static void main(String[] args)throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);

      /* This would read all records from the Employee table. */
      System.out.println("Going to read records.....");
      List <Employee> ems = (List<Employee>)
         smc.queryForList("Employee.getAll", null);
      Employee em = null;
		
      for (Employee e : ems) {
         System.out.print("  " + e.getId());
         System.out.print("  " + e.getFirstName());
         System.out.print("  " + e.getLastName());
         System.out.print("  " + e.getSalary());
         em = e; 
         System.out.println("");
      }    
		
      System.out.println("Records Read Successfully ");
   }
}

संकलन और भागो

उपर्युक्त सॉफ्टवेयर को संकलित करने और चलाने के लिए यहां चरण दिए गए हैं। सुनिश्चित करें कि आपने संकलन और निष्पादन के लिए आगे बढ़ने से पहले PATH और CLASSPATH को उचित रूप से सेट किया है।

  • जैसा कि ऊपर दिखाया गया है Employee.xml बनाएं।
  • जैसा कि ऊपर दिखाया गया है, Employee.java बनाएं और इसे संकलित करें।
  • जैसा कि ऊपर दिखाया गया है और इसे संकलित करें।
  • प्रोग्राम को चलाने के लिए इबैटिसराइड बाइनरी निष्पादित करें।

आपको निम्न परिणाम मिलेगा, और एक रिकॉर्ड EMPLOYEE तालिका से निम्नानुसार पढ़ा जाएगा -

Going to read records.....
   1  Zara  Ali  5000
Record Reads Successfully

हमने चर्चा की, आखिरी अध्याय में, iBATIS का उपयोग करके टेबल पर READ ऑपरेशन कैसे करें। यह अध्याय बताता है कि आप iBATIS का उपयोग करके किसी तालिका में रिकॉर्ड कैसे अपडेट कर सकते हैं।

हमारे पास MySQL में निम्न EMPLOYEE तालिका है -

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

इस तालिका में केवल एक रिकॉर्ड निम्नानुसार है -

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
|  1 | Zara       | Ali       |   5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)

कर्मचारी POJO वर्ग

Udpate कार्रवाई करने के लिए, आपको Employee.java फ़ाइल को संशोधित करना होगा -

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   /* Define constructors for the Employee class. */
   public Employee() {}
  
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }

   /* Here are the required method definitions */
   public int getId() {
      return id;
   }
	
   public void setId(int id) {
      this.id = id;
   }
	
   public String getFirstName() {
      return first_name;
   }
	
   public void setFirstName(String fname) {
      this.first_name = fname;
   }
	
   public String getLastName() {
      return last_name;
   }
   public void setlastName(String lname) {
      this.last_name = lname;
   }
	
   public int getSalary() {
      return salary;
   }
	
   public void setSalary(int salary) {
      this.salary = salary;
   }

} /* End of Employee */

Employee.xml फ़ाइल

IBATIS का उपयोग करते हुए SQL मैपिंग स्टेटमेंट को परिभाषित करने के लिए, हम Employee.xml में <update> टैग जोड़ेंगे और इस टैग परिभाषा के अंदर, हम एक "id" को परिभाषित करेंगे जिसका उपयोग डेटाबेस पर SQL UPDATE क्वेरी को निष्पादित करने के लिए IbatisUpdate.java फ़ाइल में किया जाएगा।

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee">

   <insert id="insert" parameterClass="Employee">
      INSERT INTO EMPLOYEE(first_name, last_name, salary)
      values (#first_name#, #last_name#, #salary#)

      <selectKey resultClass="int" keyProperty="id">
         select last_insert_id() as id
      </selectKey>
   </insert>

   <select id="getAll" resultClass="Employee">
      SELECT * FROM EMPLOYEE
   </select>

   <update id="update" parameterClass="Employee">
      UPDATE EMPLOYEE
      SET    first_name = #first_name#
      WHERE  id = #id#
   </update>
	
</sqlMap>

IbatisUpdate.java फ़ाइल

इस फ़ाइल में कर्मचारी तालिका में रिकॉर्ड अपडेट करने के लिए आवेदन स्तर तर्क है -

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisUpdate{
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);

      /* This would update one record in Employee table. */
      System.out.println("Going to update record.....");
      Employee rec = new Employee();
      rec.setId(1);
      rec.setFirstName( "Roma");
      smc.update("Employee.update", rec );
      System.out.println("Record updated Successfully ");

      System.out.println("Going to read records.....");
      List <Employee> ems = (List<Employee>)
         smc.queryForList("Employee.getAll", null);
      Employee em = null;
		
      for (Employee e : ems) {
         System.out.print("  " + e.getId());
         System.out.print("  " + e.getFirstName());
         System.out.print("  " + e.getLastName());
         System.out.print("  " + e.getSalary());
         em = e; 
         System.out.println("");
      }    

      System.out.println("Records Read Successfully ");
   }
}

संकलन और भागो

उपर्युक्त सॉफ्टवेयर को संकलित करने और चलाने के लिए यहां चरण दिए गए हैं। सुनिश्चित करें कि आपने संकलन और निष्पादन के लिए आगे बढ़ने से पहले PATH और CLASSPATH को उचित रूप से सेट किया है।

  • जैसा कि ऊपर दिखाया गया है Employee.xml बनाएं।
  • जैसा कि ऊपर दिखाया गया है, Employee.java बनाएं और इसे संकलित करें।
  • जैसा कि ऊपर दिखाया गया है और इसे संकलित करें।
  • कार्यक्रम को चलाने के लिए द्विआधारी IbatisUpdate निष्पादित करें।

आपको निम्नलिखित परिणाम मिलेगा, और एक रिकॉर्ड को EMPLOYEE तालिका में अपडेट किया जाएगा और बाद में, उसी रिकॉर्ड को EMPLOYEE तालिका से पढ़ा जाएगा।

Going to update record.....
Record updated Successfully
Going to read records.....
   1  Roma  Ali  5000
Records Read Successfully

यह अध्याय बताता है कि iBATIS का उपयोग करके किसी तालिका से रिकॉर्ड को कैसे हटाया जाए।

हमारे पास MySQL में निम्न EMPLOYEE तालिका है -

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

मान लें कि इस तालिका में दो रिकॉर्ड हैं -

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
|  1 | Zara       | Ali       |   5000 |
|  2 | Roma       | Ali       |   3000 |
+----+------------+-----------+--------+
2 row in set (0.00 sec)

कर्मचारी POJO वर्ग

डिलीट ऑपरेशन करने के लिए, आपको Employee.java फ़ाइल को संशोधित करने की आवश्यकता नहीं है। आइए हम इसे बनाए रखें क्योंकि यह पिछले अध्याय में था।

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   /* Define constructors for the Employee class. */
   public Employee() {}
  
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }

   /* Here are the required method definitions */
   public int getId() {
      return id;
   }
	
   public void setId(int id) {
      this.id = id;
   }
	
   public String getFirstName() {
      return first_name;
   }
	
   public void setFirstName(String fname) {
      this.first_name = fname;
   }
	
   public String getLastName() {
      return last_name;
   }
	
   public void setlastName(String lname) {
      this.last_name = lname;
   }
	
   public int getSalary() {
      return salary;
   }
	
   public void setSalary(int salary) {
      this.salary = salary;
   }

} /* End of Employee */

Employee.xml फ़ाइल

IBATIS का उपयोग करके SQL मैपिंग स्टेटमेंट को परिभाषित करने के लिए, हम Employee.xml में <Delete> टैग जोड़ेंगे और इस टैग परिभाषा के अंदर, हम एक "id" को परिभाषित करेंगे जिसका उपयोग डेटाबेस पर SQL DELETE क्वेरी को निष्पादित करने के लिए IbatisDelete.java फ़ाइल में किया जाएगा।

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee">

   <insert id="insert" parameterClass="Employee">
      INSERT INTO EMPLOYEE(first_name, last_name, salary)
      values (#first_name#, #last_name#, #salary#)

      <selectKey resultClass="int" keyProperty="id">
         select last_insert_id() as id
      </selectKey>
   </insert>

   <select id="getAll" resultClass="Employee">
      SELECT * FROM EMPLOYEE
   </select>

   <update id="update" parameterClass="Employee">
      UPDATE EMPLOYEE
      SET    first_name = #first_name#
      WHERE  id = #id#
   </update>

   <delete id="delete" parameterClass="int">
      DELETE FROM EMPLOYEE
      WHERE  id = #id#
   </delete>

</sqlMap>

IbatisDelete.java फ़ाइल

इस फ़ाइल में कर्मचारी स्तर से रिकॉर्ड हटाने के लिए आवेदन स्तर तर्क है -

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisDelete{
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);

      /* This would delete one record in Employee table. */
      System.out.println("Going to delete record.....");
      int id = 1;

      smc.delete("Employee.delete", id );
      System.out.println("Record deleted Successfully ");

      System.out.println("Going to read records.....");
      List <Employee> ems = (List<Employee>)
         smc.queryForList("Employee.getAll", null);
      Employee em = null;
		
      for (Employee e : ems) {
         System.out.print("  " + e.getId());
         System.out.print("  " + e.getFirstName());
         System.out.print("  " + e.getLastName());
         System.out.print("  " + e.getSalary());
         em = e; 
         System.out.println("");
      }    

      System.out.println("Records Read Successfully ");
   }
}

संकलन और भागो

उपर्युक्त सॉफ्टवेयर को संकलित करने और चलाने के लिए यहां चरण दिए गए हैं। सुनिश्चित करें कि आपने संकलन और निष्पादन के लिए आगे बढ़ने से पहले PATH और CLASSPATH को उचित रूप से सेट किया है।

  • जैसा कि ऊपर दिखाया गया है Employee.xml बनाएं।
  • जैसा कि ऊपर दिखाया गया है, Employee.java बनाएं और इसे संकलित करें।
  • जैसा कि ऊपर दिखाया गया है और इसे संकलित करें।
  • कार्यक्रम को चलाने के लिए इबीटिसडे बाइट निष्पादित करें।

आपको निम्न परिणाम मिलेगा, और ID = 1 के साथ एक रिकॉर्ड EMPLOYEE तालिका से हटा दिया जाएगा और शेष रिकॉर्ड पढ़ा जाएगा।

Going to delete record.....
Record deleted Successfully
Going to read records.....
   2  Roma  Ali  3000
Records Read Successfully

परिणाम तत्व तत्व iBATIS में सबसे महत्वपूर्ण और शक्तिशाली तत्व है। आप iBATIS ResultMap का उपयोग करके 90% JDBC कोडिंग को कम कर सकते हैं और कुछ मामलों में, यह आपको उन चीजों को करने की अनुमति देता है जो JDBC भी समर्थन नहीं करता है।

ResultMaps का डिज़ाइन ऐसा है कि सरल कथनों के लिए स्पष्ट परिणाम मैपिंग की आवश्यकता नहीं होती है, और अधिक जटिल कथनों की आवश्यकता होती है रिश्तों का वर्णन करने के लिए बिल्कुल आवश्यक नहीं है।

यह अध्याय iBATIS ResultMaps का एक सरल परिचय प्रदान करता है।

हमारे पास MySQL में निम्न EMPLOYEE तालिका है -

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

इस तालिका के निम्न दो रिकॉर्ड हैं -

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
|  1 | Zara       | Ali       |   5000 |
|  2 | Roma       | Ali       |   3000 |
+----+------------+-----------+--------+
2 row in set (0.00 sec)

कर्मचारी POJO वर्ग

IBATIS ResultMap का उपयोग करने के लिए, आपको Employee.java फ़ाइल को संशोधित करने की आवश्यकता नहीं है। आइए हम इसे बनाए रखें क्योंकि यह पिछले अध्याय में था।

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   /* Define constructors for the Employee class. */
   public Employee() {}
  
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }

   /* Here are the required method definitions */
   public int getId() {
      return id;
   }
	
   public void setId(int id) {
      this.id = id;
   }
	
   public String getFirstName() {
      return first_name;
   }
	
   public void setFirstName(String fname) {
      this.first_name = fname;
   }
	
   public String getLastName() {
      return last_name;
   }
	
   public void setlastName(String lname) {
      this.last_name = lname;
   }
	
   public int getSalary() {
      return salary;
   }
	
   public void setSalary(int salary) {
      this.salary = salary;
   }

} /* End of Employee */

Employee.xml फ़ाइल

यहां हम <resultMap> </ resultMap> टैग शुरू करने के लिए Employee.xml को संशोधित करेंगे। इस टैग में एक आईडी होगी, जिसे हमारे <select> टैग के resultMap विशेषता में इस परिणाम मानचित्र को चलाने की आवश्यकता है।

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee">

   <!-- Perform Insert Operation -->
	
   <insert id="insert" parameterClass="Employee">
      INSERT INTO EMPLOYEE(first_name, last_name, salary)
      values (#first_name#, #last_name#, #salary#)

      <selectKey resultClass="int" keyProperty="id">
         select last_insert_id() as id
      </selectKey>
   </insert>

   <!-- Perform Read Operation -->
   <select id="getAll" resultClass="Employee">
      SELECT * FROM EMPLOYEE
   </select>

   <!-- Perform Update Operation -->
   <update id="update" parameterClass="Employee">
      UPDATE EMPLOYEE
      SET    first_name = #first_name#
      WHERE  id = #id#
    </update>

   <!-- Perform Delete Operation -->
   <delete id="delete" parameterClass="int">
      DELETE FROM EMPLOYEE
      WHERE  id = #id#
   </delete>

   <!-- Using ResultMap -->
   <resultMap id="result" class="Employee">
      <result property="id" column="id"/>
      <result property="first_name" column="first_name"/>
      <result property="last_name" column="last_name"/>
      <result property="salary" column="salary"/>
   </resultMap> 
	
   <select id="useResultMap" resultMap="result">
      SELECT * FROM EMPLOYEE
      WHERE id=#id#
   </select>

</sqlMap>

IbatisResultMap.java फ़ाइल

इस फाइल में एप्लिकेशन स्तर का तर्क है, जिसमें परिणाम तालिका का उपयोग करते हुए कर्मचारी तालिका से रिकॉर्ड पढ़ें -

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisResultMap{
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);

      int id = 1;
      System.out.println("Going to read record.....");
      Employee e = (Employee)smc.queryForObject ("Employee.useResultMap", id);

      System.out.println("ID:  " + e.getId());
      System.out.println("First Name:  " + e.getFirstName());
      System.out.println("Last Name:  " + e.getLastName());
      System.out.println("Salary:  " + e.getSalary());
      System.out.println("Record read Successfully ");
   }
}

संकलन और भागो

उपर्युक्त सॉफ्टवेयर को संकलित करने और चलाने के लिए यहां चरण दिए गए हैं। सुनिश्चित करें कि आपने संकलन और निष्पादन के लिए आगे बढ़ने से पहले PATH और CLASSPATH को उचित रूप से सेट किया है।

  • जैसा कि ऊपर दिखाया गया है Employee.xml बनाएं।
  • जैसा कि ऊपर दिखाया गया है, Employee.java बनाएं और इसे संकलित करें।
  • जैसा कि ऊपर दिखाया गया है और इसे संकलित करें।
  • प्रोग्राम को चलाने के लिए IbatisResultMap बाइनरी निष्पादित करें।

आपको निम्न परिणाम मिलेगा जो EMPLOYEE तालिका पर एक पढ़ने वाला ऑपरेशन है।

Going to read record.....
ID:  1
First Name:  Zara
Last Name:  Ali
Salary:  5000
Record read Successfully

आप iBATIS कॉन्फ़िगरेशन का उपयोग करके संग्रहीत कार्यविधि को कॉल कर सकते हैं। सबसे पहले, हम समझते हैं कि MySQL में एक संग्रहीत कार्यविधि कैसे बनाई जाए।

हमारे पास MySQL में निम्न EMPLOYEE तालिका है -

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

आइए हम MySQL डेटाबेस में निम्नलिखित संग्रहित प्रक्रिया बनाते हैं -

DELIMITER $$

   DROP PROCEDURE IF EXISTS `testdb`.`getEmp` $$ CREATE PROCEDURE `testdb`.`getEmp` (IN empid INT) BEGIN SELECT * FROM EMPLOYEE WHERE ID = empid; END $$

DELIMITER;

आइए इस बात पर विचार करें कि EMPLOYEE तालिका के निम्न दो रिकॉर्ड हैं -

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
|  1 | Zara       | Ali       |   5000 |
|  2 | Roma       | Ali       |   3000 |
+----+------------+-----------+--------+
2 row in set (0.00 sec)

कर्मचारी POJO वर्ग

संग्रहीत कार्यविधि का उपयोग करने के लिए, आपको Employee.java फ़ाइल को संशोधित करने की आवश्यकता नहीं है। आइए हम इसे बनाए रखें क्योंकि यह पिछले अध्याय में था।

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   /* Define constructors for the Employee class. */
   public Employee() {}
  
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }

   /* Here are the required method definitions */
   public int getId() {
      return id;
   }
	
   public void setId(int id) {
      this.id = id;
   }
	
   public String getFirstName() {
      return first_name;
   }
	
   public void setFirstName(String fname) {
      this.first_name = fname;
   }
	
   public String getLastName() {
      return last_name;
   }
	
   public void setlastName(String lname) {
      this.last_name = lname;
   }
	
   public int getSalary() {
      return salary;
   }
	
   public void setSalary(int salary) {
      this.salary = salary;
   }

} /* End of Employee */

Employee.xml फ़ाइल

यहाँ हम Employee.xml को संशोधित करने के लिए <प्रक्रिया> </ प्रक्रिया> और <पैरामीटरमैप> </ पैरामीटर मैप्स> टैग पेश करेंगे। यहां <प्रक्रिया> </ प्रक्रिया> टैग में एक आईडी होगी जिसका उपयोग हम अपने आवेदन में संग्रहीत प्रक्रिया को कॉल करने के लिए करेंगे।

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee">

   <!-- Perform Insert Operation -->
   <insert id="insert" parameterClass="Employee">
      INSERT INTO EMPLOYEE(first_name, last_name, salary)
      values (#first_name#, #last_name#, #salary#)

      <selectKey resultClass="int" keyProperty="id">
         select last_insert_id() as id
      </selectKey>
   </insert>

   <!-- Perform Read Operation -->
   <select id="getAll" resultClass="Employee">
      SELECT * FROM EMPLOYEE
   </select>

   <!-- Perform Update Operation -->
   <update id="update" parameterClass="Employee">
      UPDATE EMPLOYEE
      SET    first_name = #first_name#
      WHERE  id = #id#
   </update>

   <!-- Perform Delete Operation -->
   <delete id="delete" parameterClass="int">
      DELETE FROM EMPLOYEE
      WHERE  id = #id#
   </delete>

   <!-- To call stored procedure. -->
   <procedure id="getEmpInfo" resultClass="Employee" parameterMap="getEmpInfoCall">
      { call getEmp( #acctID# ) } 
   </procedure>
	
   <parameterMap id="getEmpInfoCall" class="map">
      <parameter property="acctID" jdbcType="INT" javaType="java.lang.Integer" mode="IN"/>
   </parameterMap>

</sqlMap>

IbatisSP.java फ़ाइल

इस फाइल में कर्मचारी स्तर से कर्मचारियों के नाम को पढ़ने के लिए एप्लिकेशन स्तर तर्क दिया गया है -

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisSP{
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);

      int id = 1;
      System.out.println("Going to read employee name.....");
      Employee e = (Employee) smc.queryForObject ("Employee.getEmpInfo", id);

      System.out.println("First Name:  " + e.getFirstName());
      System.out.println("Record name Successfully ");
   }
}

संकलन और भागो

उपर्युक्त सॉफ्टवेयर को संकलित करने और चलाने के लिए यहां चरण दिए गए हैं। सुनिश्चित करें कि आपने संकलन और निष्पादन के लिए आगे बढ़ने से पहले PATH और CLASSPATH को उचित रूप से सेट किया है।

  • जैसा कि ऊपर दिखाया गया है Employee.xml बनाएं।
  • जैसा कि ऊपर दिखाया गया है, Employee.java बनाएं और इसे संकलित करें।
  • जैसा कि ऊपर दिखाया गया है और इसे संकलित करें।
  • कार्यक्रम को चलाने के लिए इब्रैटिसपी बाइनरी निष्पादित करें।

आपको निम्न परिणाम मिलेगा:

Going to read employee name.....
First Name:  Zara
Record name Successfully

डायनेमिक SQL iBATIS की एक बहुत शक्तिशाली विशेषता है। कभी-कभी आपको अपने पैरामीटर ऑब्जेक्ट की स्थिति के आधार पर WHERE क्लॉज मानदंड को बदलना होगा। ऐसी स्थितियों में, iBATIS डायनेमिक SQL टैग्स का एक सेट प्रदान करता है जिसका उपयोग SQL के पुन: प्रयोज्य और लचीलेपन को बढ़ाने के लिए मैप किए गए कथनों के भीतर किया जा सकता है।

सभी तर्क कुछ अतिरिक्त टैग का उपयोग करते हुए .XML फ़ाइल में डाल दिए जाते हैं। निम्नलिखित एक उदाहरण है जहां SELECT स्टेटमेंट दो तरीकों से काम करेगा -

यदि आप एक आईडी पास करते हैं, तो यह उस आईडी के अनुरूप सभी रिकॉर्ड लौटा देगा।

अन्यथा, यह उन सभी रिकॉर्डों को लौटा देगा जहां कर्मचारी आईडी NULL पर सेट है।

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee">

   <select id="findByID" resultClass="Employee">
      SELECT * FROM EMPLOYEE
		
      <dynamic prepend="WHERE ">
         <isNull property="id">
            id IS NULL
         </isNull>
			
         <isNotNull property="id">
            id = #id#
         </isNotNull>
      </dynamic>
		
   </select>
</sqlMap>

आप निम्न प्रकार से <.NotEmpty> टैग का उपयोग करके एक स्थिति की जांच कर सकते हैं। यहां एक शर्त तभी जोड़ी जाएगी, जब कोई पारित संपत्ति खाली न हो।

..................
<select id="findByID" resultClass="Employee">
   SELECT * FROM EMPLOYEE
	
   <dynamic prepend="WHERE ">
      <isNotEmpty property="id">
         id = #id#
      </isNotEmpty>
   </dynamic>
	
</select>
..................

यदि आप एक ऐसी क्वेरी चाहते हैं, जहाँ हम किसी कर्मचारी का आईडी और / या पहले नाम का चयन कर सकें, तो आपका चयन विवरण निम्नानुसार होगा:

..................
<select id="findByID" resultClass="Employee">
   SELECT * FROM EMPLOYEE
	
   <dynamic prepend="WHERE ">
      <isNotEmpty prepend="AND" property="id">
         id = #id#
      </isNotEmpty>
		
      <isNotEmpty prepend="OR" property="first_name">
         first_name = #first_name#
      </isNotEmpty>
   </dynamic>
</select>
..................

गतिशील SQL उदाहरण

निम्न उदाहरण दिखाता है कि आप डायनेमिक SQL के साथ SELECT स्टेटमेंट कैसे लिख सकते हैं। गौर करें, हमारे पास MySQL में निम्न EMPLOYEE तालिका है -

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

मान लेते हैं कि इस तालिका का केवल एक रिकॉर्ड निम्नानुसार है -

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
|  1 | Zara       | Ali       |   5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)

कर्मचारी POJO वर्ग

रीड ऑपरेशन करने के लिए, हमें Employee.java में एक कर्मचारी वर्ग इस प्रकार है -

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   /* Define constructors for the Employee class. */
   public Employee() {}
  
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }

   /* Here are the method definitions */
   public int getId() {
      return id;
   }
	
   public String getFirstName() {
      return first_name;
   }
	
   public String getLastName() {
      return last_name;
   }
	
   public int getSalary() {
      return salary;
   }
	
} /* End of Employee */

Employee.xml फ़ाइल

IBATIS का उपयोग करते हुए SQL मैपिंग स्टेटमेंट को परिभाषित करने के लिए, हम Employee.xml में निम्नलिखित संशोधित <select> टैग जोड़ेंगे और इस टैग परिभाषा के अंदर, हम एक "id" को परिभाषित करेंगे जिसका उपयोग IbatisReadDy.java में गतिशील SQL चयन क्वेरी को निष्पादित करने के लिए किया जाएगा। डेटाबेस।

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee">
   <select id="findByID" resultClass="Employee">
      SELECT * FROM EMPLOYEE
	
      <dynamic prepend="WHERE ">
         <isNotNull property="id">
            id = #id#
         </isNotNull>
      </dynamic>
		
   </select>
</sqlMap>

उपरोक्त चयन कथन दो तरीकों से काम करेगा -

  • यदि आप एक आईडी पास करते हैं, तो यह उस आईडी के अनुरूप रिकॉर्ड देता है अन्यथा, यह सभी रिकॉर्ड लौटाता है।

IbatisReadDy.java फ़ाइल

इस फ़ाइल में कर्मचारी स्तर से सशर्त रिकॉर्ड पढ़ने के लिए आवेदन स्तर तर्क है -

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisReadDy{
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd=Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc=SqlMapClientBuilder.buildSqlMapClient(rd);

      /* This would read all records from the Employee table.*/
      System.out.println("Going to read records.....");
      Employee rec = new Employee();
      rec.setId(1);

      List <Employee> ems = (List<Employee>)  
         smc.queryForList("Employee.findByID", rec);
      Employee em = null;
		
      for (Employee e : ems) {
         System.out.print("  " + e.getId());
         System.out.print("  " + e.getFirstName());
         System.out.print("  " + e.getLastName());
         System.out.print("  " + e.getSalary());
         em = e; 
         System.out.println("");
      }    
      System.out.println("Records Read Successfully ");
   }
}

संकलन और भागो

उपर्युक्त सॉफ्टवेयर को संकलित करने और चलाने के लिए यहां चरण दिए गए हैं। सुनिश्चित करें कि आपने संकलन और निष्पादन के लिए आगे बढ़ने से पहले PATH और CLASSPATH को उचित रूप से सेट किया है।

  • जैसा कि ऊपर दिखाया गया है Employee.xml बनाएं।
  • जैसा कि ऊपर दिखाया गया है, Employee.java बनाएं और इसे संकलित करें।
  • जैसा कि ऊपर दिखाया गया है और इसे संकलित करें।
  • कार्यक्रम को चलाने के लिए IbatisReadDy बाइनरी निष्पादित करें।

आपको निम्न परिणाम मिलेगा, और EMPLOYEE तालिका से एक रिकॉर्ड पढ़ा जाएगा।

Going to read records.....
   1  Zara  Ali  5000
Record Reads Successfully

ऊपर दिए गए उदाहरण को पास करके देखें nullके रूप में smc.queryForList ( "Employee.findByID", नल) ।

iBATIS OGNL एक्सप्रेशन

iBATIS अन्य तत्वों को समाप्त करने के लिए शक्तिशाली OGNL आधारित अभिव्यक्तियाँ प्रदान करता है।

  • यदि कथन
  • चुनें, कब, अन्यथा कथन
  • कथन
  • कथन पर पहुंचें

इफ स्टेटमेंट

गतिशील एसक्यूएल में सबसे आम बात सशर्त रूप से एक खंड का एक हिस्सा शामिल है। उदाहरण के लिए -

<select id="findActiveBlogWithTitleLike" parameterType="Blog" resultType="Blog">
   SELECT * FROM BLOG
   WHERE state = 'ACTIVE.
	
   <if test="title != null">
      AND title like #{title}
   </if>
	
</select>

यह कथन वैकल्पिक पाठ खोज प्रकार की कार्यक्षमता प्रदान करता है। यदि आप बिना किसी शीर्षक के पास करते हैं, तो सभी सक्रिय ब्लॉग वापस आ जाते हैं। लेकिन अगर आप एक शीर्षक में पास करते हैं, तो यह दिए गए शीर्षक के साथ दिखेगाlike स्थिति।

आप कई शामिल कर सकते हैं if परिस्थितियां इस प्रकार हैं -

<select id="findActiveBlogWithTitleLike" parameterType="Blog" resultType="Blog">
   SELECT * FROM BLOG
   WHERE state = 'ACTIVE.
	
   <if test="title != null">
      AND title like #{title}
   </if>
	
   <if test="author != null">
      AND author like #{author}
   </if>
	
</select>

चयन, कब, और अन्यथा विवरण

iBATIS एक प्रदान करता है chooseवह तत्व जो जावा के स्विच स्टेटमेंट के समान है। यह कई विकल्पों में से केवल एक मामले को चुनने में मदद करता है।

निम्नलिखित उदाहरण केवल शीर्षक द्वारा खोजेगा यदि कोई प्रदान किया गया है, तो केवल लेखक द्वारा यदि कोई प्रदान किया गया है। यदि न तो प्रदान किया जाता है, तो यह केवल चुनिंदा ब्लॉग लौटाता है -

<select id="findActiveBlogWithTitleLike" parameterType="Blog" resultType="Blog">
   SELECT * FROM BLOG
   WHERE state = 'ACTIVE.
	
   <choose>
      <when test="title != null">
         AND title like #{title}
      </when>
		
      <when test="author != null and author.name != null">
         AND author like #{author}
      </when>
		
      <otherwise>
         AND featured = 1
      </otherwise>
   </choose>
	
</select>

द स्टेटमेंट

हमारे पिछले उदाहरणों पर एक नज़र डालें कि क्या होता है अगर कोई भी शर्त पूरी नहीं होती है। आप एक एसक्यूएल के साथ अंत करेंगे जो इस तरह दिखता है -

SELECT * FROM BLOG
WHERE

यह विफल होगा, लेकिन iBATIS के पास एक सरल परिवर्तन के साथ एक सरल समाधान है, सब कुछ ठीक काम करता है -

<select id="findActiveBlogLike" parameterType="Blog" resultType="Blog">
   SELECT * FROM BLOG
	
   <where>
      <if test="state != null">
         state = #{state}
      </if>
		
      <if test="title != null">
         AND title like #{title}
      </if>
		
      <if test="author != null>
         AND author like #{author}
      </if>
   </where>
	
</select>

whereतत्व एक सम्मिलित करता है जहां केवल जब युक्त टैग किसी भी सामग्री को लौट आते हैं। इसके अलावा, अगर वह सामग्री AND या OR से शुरू होती है, तो वह इसे बंद करना जानता है।

फॉर्च्यून स्टेटमेंट

फ़ॉर्च तत्व आपको एक संग्रह निर्दिष्ट करने और आइटम और इंडेक्स चर घोषित करने की अनुमति देता है जिसका उपयोग तत्व के शरीर के अंदर किया जा सकता है।

यह आपको स्ट्रिंग्स को खोलने और बंद करने को निर्दिष्ट करने की अनुमति देता है, और पुनरावृत्तियों के बीच में विभाजक जोड़ने के लिए अनुमति देता है। आप एक निर्माण कर सकते हैंIN हालत इस प्रकार है -

<select id="selectPostIn" resultType="domain.blog.Post">
   SELECT *
   FROM POST P
   WHERE ID in
	
   <foreach item="item" index="index" collection="list"
      open="(" separator="," close=")">
      #{item}
   </foreach>
	
</select>

आईबैटिस के साथ काम करते हुए अपने कार्यक्रम को डिबग करना आसान है। iBATIS ने अंतर्निहित लॉगिंग समर्थन किया है और यह निम्न लॉगिंग लाइब्रेरी के साथ काम करता है और इस क्रम में उनके लिए खोज करता है।

  • जकार्ता कॉमन्स लॉगिंग (JCL)।
  • Log4J
  • JDK लॉगिंग

आप उपरोक्त सूचीबद्ध पुस्तकालयों में से किसी का उपयोग iBATIS के साथ कर सकते हैं।

Log4J के साथ डिबगिंग

मान लें कि आप लॉगिंग के लिए Log4J का उपयोग करने जा रहे हैं। आगे बढ़ने से पहले, आपको निम्नलिखित बिंदुओं को पार करने की आवश्यकता है -

  • Log4J JAR फ़ाइल (log4j- {version} .jar) CLASSPATH में होनी चाहिए।
  • आपके पास CLASSPATH में log4j.properties उपलब्ध है।

निम्नलिखित log4j.properties फ़ाइल है। ध्यान दें कि कुछ लाइनों पर टिप्पणी की गई है। यदि आपको अतिरिक्त डीबगिंग जानकारी की आवश्यकता है, तो आप उन्हें असहज कर सकते हैं।

# Global logging configuration
log4j.rootLogger = ERROR, stdout

log4j.logger.com.ibatis = DEBUG

# shows SQL of prepared statements
#log4j.logger.java.sql.Connection = DEBUG

# shows parameters inserted into prepared statements
#log4j.logger.java.sql.PreparedStatement = DEBUG

# shows query results
#log4j.logger.java.sql.ResultSet = DEBUG

#log4j.logger.java.sql.Statement = DEBUG

# Console output
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %5p [%t] − %m%n

आप Apaches साइट से Log4J के लिए पूर्ण प्रलेखन पा सकते हैं - Log4J प्रलेखन ।

iBATIS डिबगिंग उदाहरण

निम्नलिखित जावा वर्ग एक बहुत ही सरल उदाहरण है जो जावा अनुप्रयोगों के लिए लॉग 4 जे लॉगिंग लाइब्रेरी का उपयोग करता है। हम उपर्युक्त संपत्ति फ़ाइल का उपयोग करेंगे जो CLASSPATH में निहित है।

import org.apache.log4j.Logger;

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class IbatisUpdate{
   static Logger log = Logger.getLogger(IbatisUpdate.class.getName());

   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);

      /* This would insert one record in Employee table. */
      log.info("Going to update record.....");
      Employee rec = new Employee();
      rec.setId(1);
      rec.setFirstName( "Roma");
      smc.update("Employee.update", rec );
      log.info("Record updated Successfully ");

      log.debug("Going to read records.....");
      List <Employee> ems = (List<Employee>) 
         smc.queryForList("Employee.getAll", null);
      Employee em = null;
		
      for (Employee e : ems) {
         System.out.print("  " + e.getId());
         System.out.print("  " + e.getFirstName());
         System.out.print("  " + e.getLastName());
         System.out.print("  " + e.getSalary());
         em = e;
         System.out.println("");
      }
      log.debug("Records Read Successfully ");
   }
}

संकलन और भागो

सबसे पहले, सुनिश्चित करें कि आपने संकलन और निष्पादन के लिए आगे बढ़ने से पहले PATH और CLASSPATH को उचित रूप से सेट किया है।

  • जैसा कि ऊपर दिखाया गया है Employee.xml बनाएं।
  • जैसा कि ऊपर दिखाया गया है, Employee.java बनाएं और इसे संकलित करें।
  • जैसा कि ऊपर दिखाया गया है और इसे संकलित करें।
  • जैसा कि ऊपर दिखाया गया है log4j.properties बनाएँ।
  • कार्यक्रम को चलाने के लिए द्विआधारी IbatisUpdate निष्पादित करें।

आपको निम्न परिणाम मिलेगा। EMPLOYEE तालिका में एक रिकॉर्ड अपडेट किया जाएगा और बाद में, उसी रिकॉर्ड को EMPLOYEE तालिका से पढ़ा जाएगा।

DEBUG [main] - Created connection 28405330.
DEBUG [main] - Returned connection 28405330 to pool.
DEBUG [main] - Checked out connection 28405330 from pool.
DEBUG [main] - Returned connection 28405330 to pool.
   1  Roma  Ali  5000
   2  Zara  Ali  5000
   3  Zara  Ali  5000

डिबग विधियाँ

उपरोक्त उदाहरण में, हमने केवल उपयोग किया है info() विधि, हालांकि आप अपनी आवश्यकताओं के अनुसार निम्न विधियों में से किसी का उपयोग कर सकते हैं -

public void trace(Object message);
public void debug(Object message);
public void info(Object message);
public void warn(Object message);
public void error(Object message);
public void fatal(Object message);

IBATIS और हाइबरनेट के बीच प्रमुख अंतर हैं। दोनों समाधान अपने विशिष्ट डोमेन को देखते हुए अच्छी तरह से काम करते हैं। iBATIS के मामले में सुझाव दिया गया है -

  • आप अपनी खुद की SQL बनाना चाहते हैं और आप उन्हें बनाए रखने के लिए तैयार हैं।
  • आपका वातावरण रिलेशनल डेटा मॉडल द्वारा संचालित है।
  • आपको मौजूदा और जटिल स्कीमाओं पर काम करना होगा।

हाइबरनेट का उपयोग करें यदि वातावरण ऑब्जेक्ट मॉडल द्वारा संचालित है और स्वचालित रूप से SQL उत्पन्न करने की आवश्यकता है।

IBATIS और हाइबरनेट के बीच अंतर

Hibernate और iBATIS दोनों उद्योग में उपलब्ध ओपन सोर्स ऑब्जेक्ट रिलेशनल मैपिंग (ORM) टूल हैं। इनमें से प्रत्येक उपकरण का उपयोग आपके द्वारा उपयोग किए जा रहे संदर्भ पर निर्भर करता है।

निम्न तालिका iBATIS और हाइबरनेट के बीच अंतर पर प्रकाश डालती है -

iBATIS हाइबरनेट
iBATIS सरल है। यह बहुत छोटे पैकेज के आकार में आता है। हाइबरनेट आपके लिए SQL जेनरेट करता है जिसका मतलब है कि आपको SQL बनाने पर समय नहीं देना है।
iBATIS लचीला है। यह तेजी से विकास का समय प्रदान करता है। हाइबरनेट अत्यधिक स्केलेबल है। यह बहुत अधिक उन्नत कैश प्रदान करता है।
iBATIS SQL का उपयोग करता है जो डेटाबेस पर निर्भर हो सकता है। हाइबरनेट HQL का उपयोग करता है जो डेटाबेस से अपेक्षाकृत स्वतंत्र है। हाइबरनेट में db बदलना आसान है।
iBatis अपने POJO Objets के लिए JDBC API से ResultSet को मैप करता है, इसलिए आपको टेबल संरचनाओं की परवाह नहीं करनी है। हाइबरनेट करें अपने जावा POJO ऑब्जेक्ट्स को डेटाबेस टेबल पर मैप करें।
IBATIS में संग्रहीत प्रक्रिया का उपयोग करना काफी आसान है। संग्रहीत प्रक्रियाओं का उपयोग हाइबरनेट में थोड़ा मुश्किल है।

Hibernate और iBATIS दोनों को SPRING फ्रेमवर्क से अच्छा समर्थन प्राप्त होता है, इसलिए उनमें से किसी एक को चुनना समस्या नहीं होनी चाहिए।

iBATOR iBATIS के लिए एक कोड जनरेटर है। iBATOR एक या एक से अधिक डेटाबेस तालिकाओं का परिचय देता है और iBATIS कलाकृतियों को उत्पन्न करता है जिनका उपयोग तालिकाओं तक पहुंचने के लिए किया जा सकता है।

बाद में आप अपनी आवश्यकताओं को पूरा करने के लिए अपना कस्टम SQL कोड या संग्रहीत कार्यविधि लिख सकते हैं। iBator निम्नलिखित कलाकृतियों का निर्माण करता है -

  • SqlMap XML फ़ाइलें
  • तालिका की प्राथमिक कुंजी और फ़ील्ड से मिलान करने के लिए जावा क्लासेस
  • उपरोक्त वस्तुओं का उपयोग करने वाले DAO वर्ग (वैकल्पिक)

iBator एक स्टैंडअलोन JAR फ़ाइल के रूप में, या एक चींटी कार्य के रूप में, या एक ग्रहण प्लगइन के रूप में चल सकता है। यह ट्यूटोरियल कमांड लाइन से iBATIS विन्यास फाइल बनाने का सबसे सरल तरीका बताता है।

डाउनलोड iBator

यदि आप ग्रहण के अलावा अन्य IDE का उपयोग कर रहे हैं तो स्टैंडअलोन JAR डाउनलोड करें। स्टैंडअलोन JAR में iBATOR चलाने के लिए एक एंट कार्य शामिल है, या आप Java कोड की कमांड लाइन से iBATOR चला सकते हैं।

  • आप डाउनलोड iBator से ज़िप फ़ाइल डाउनलोड कर सकते हैं ।

  • आप ऑनलाइन प्रलेखन - iBATOR प्रलेखन की जाँच कर सकते हैं ।

कॉन्फ़िगरेशन फ़ाइल बनाना

IBATOR चलाने के लिए, इन चरणों का पालन करें -

चरण 1

एक विन्यास फाइल बनाएं और भरें ibatorConfig.xml। कम से कम, आपको निर्दिष्ट करना होगा -

  • ए <jdbcConnection> यह निर्धारित करने के लिए कि लक्ष्य डेटाबेस से कैसे जुड़ा जाए।

  • ए <javaModelGenerator> एलिमेंट जावा मॉडल ऑब्जेक्ट के लिए लक्ष्य पैकेज और लक्ष्य प्रोजेक्ट को निर्दिष्ट करने के लिए तत्व।

  • ए <sqlMapGenerator> उत्पन्न SQL मैप फ़ाइलों के लिए लक्ष्य पैकेज और लक्ष्य परियोजना को निर्दिष्ट करने के लिए तत्व।

  • ए <daoGenerator> जनरेट किए गए DAO इंटरफेस और कक्षाओं के लिए लक्ष्य पैकेज और लक्ष्य परियोजना को निर्दिष्ट करने के लिए तत्व (यदि आप DAO उत्पन्न नहीं करना चाहते हैं तो <daoGenerator> तत्व छोड़ सकते हैं)।

  • कम से कम एक डेटाबेस <table> तत्त्व

NOTE −IBator कॉन्फ़िगरेशन फ़ाइल के उदाहरण के लिए XML कॉन्फ़िगरेशन फ़ाइल संदर्भ पृष्ठ देखें ।

चरण 2

फ़ाइल को किसी सुविधाजनक स्थान पर सहेजें, उदाहरण के लिए: \ temp \ ibatorConfig.xml।

चरण 3

अब iBator को कमांड लाइन से निम्नानुसार चलाएं -

java -jar abator.jar -configfile \temp\abatorConfig.xml -overwrite

यह iBator को आपकी कॉन्फ़िगरेशन फ़ाइल का उपयोग करके चलाने के लिए बताएगा। यह iBATOR को समान नाम वाली किसी भी मौजूदा जावा फाइल को अधिलेखित करने के लिए भी बताएगा। यदि आप किसी भी मौजूदा जावा फ़ाइल को सहेजना चाहते हैं, तो छोड़ दें−overwrite पैरामीटर।

यदि कोई विरोधाभास है, तो iBator एक नई फ़ाइल को एक अद्वितीय नाम से सहेजता है।

IBator चलाने के बाद, आपको अपने नए जनरेट किए गए कोड का उपयोग करने के लिए मानक iBATIS कॉन्फ़िगरेशन फ़ाइलों को बनाने या संशोधित करने की आवश्यकता है। यह अगले भाग में बताया गया है।

IBator चलाने के बाद कार्य

IBator चलाने के बाद, आपको अन्य iBATIS कॉन्फ़िगरेशन कलाकृतियों को बनाने या संशोधित करने की आवश्यकता है। मुख्य कार्य इस प्रकार हैं -

  • SqlMapConfig.xml फ़ाइल बनाएँ या संशोधित करें।
  • Dao.xml फ़ाइल बनाएं या संशोधित करें (केवल यदि आप iBATIS DAO फ्रेमवर्क का उपयोग कर रहे हैं)।

प्रत्येक कार्य नीचे विस्तार से वर्णित है -

SqlMapConfig.xml फ़ाइल को अद्यतन करना

iBATIS एक XML फ़ाइल का उपयोग करता है, जिसे आमतौर पर SqlMapConfig.xml नाम दिया जाता है, एक डेटाबेस कनेक्शन, एक लेनदेन प्रबंधन योजना और SQL मैप XML फ़ाइलों के लिए जानकारी निर्दिष्ट करने के लिए जो एक iBATIS सत्र में उपयोग किए जाते हैं।

iBator आपके लिए यह फ़ाइल नहीं बना सकता क्योंकि यह आपके निष्पादन परिवेश के बारे में कुछ नहीं जानता है। हालाँकि, इस फ़ाइल में कुछ आइटम सीधे iBator जनरेट की गई वस्तुओं से संबंधित हैं।

विन्यास फाइल में iBATOR की विशिष्ट आवश्यकताएं इस प्रकार हैं -

  • स्टेटमेंट नेमस्पेस सक्षम होना चाहिए।
  • iBator ने SQL मैप XML फाइल को लिस्ट किया जाना चाहिए।

उदाहरण के लिए, मान लें कि iBator ने MyTable_SqlMap.xml नामक एक SQL मैप XML फ़ाइल बनाई है, और यह फ़ाइल आपके प्रोजेक्ट के test.xml पैकेज में रखी गई है। SqlMapConfig.xml फ़ाइल में ये प्रविष्टियाँ होनी चाहिए -

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMapConfig PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">

<sqlMapConfig>
   <!-- Statement namespaces are required for Abator -->
   <settings useStatementNamespaces="true" />

   <!-- Setup the transaction manager and data source that are
   appropriate for your environment
   -->
	
   <transactionManager type="...">
      <dataSource type="...">
      </dataSource>
   </transactionManager>

   <!-- SQL Map XML files should be listed here -->
   <sqlMap resource="test/xml/MyTable_SqlMap.xml" />

</sqlMapConfig>

यदि एक से अधिक SQL मानचित्र XML फ़ाइल (जैसा कि काफी सामान्य है) है, तो फ़ाइलों को किसी भी क्रम में <लेन-देन> तत्व के बाद दोहराया जा सकता है।

Dao.xml फ़ाइल अपडेट कर रहा है

IBATIS DAO फ्रेमवर्क को एक xml फ़ाइल द्वारा कॉन्फ़िगर किया जाता है जिसे आमतौर पर dao.xml कहा जाता है।

IBATIS DAO फ्रेमवर्क इस फाइल का उपयोग DAO के लिए डेटाबेस कनेक्शन की जानकारी को नियंत्रित करने के लिए करता है, और DAO कार्यान्वयन वर्गों और DAO इंटरफेस को सूचीबद्ध करने के लिए भी करता है।

इस फ़ाइल में, आपको अपनी SqlMapConfig.xml फ़ाइल के लिए पथ निर्दिष्ट करना चाहिए, और सभी iBATOR डीएओ इंटरफेस और कार्यान्वयन कक्षाएं उत्पन्न करते हैं।

उदाहरण के लिए, मान लें कि iBator ने MyTableDAO नामक एक DAO इंटरफ़ेस और MyTableDAOImpl नामक एक कार्यान्वयन वर्ग उत्पन्न किया है, और यह कि फ़ाइलें आपके प्रोजेक्ट के test.dao पैकेज में रखी गई हैं।

Dao.xml फ़ाइल में ये प्रविष्टियाँ होनी चाहिए -

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE daoConfig PUBLIC "-//ibatis.apache.org//DTD DAO Configuration 2.0//EN" "http://ibatis.apache.org/dtd/dao-2.dtd">

<daoConfig>

   <context>
	
      <transactionManager type="SQLMAP">
         <property name="SqlMapConfigResource" value="test/SqlMapConfig.xml"/>
      </transactionManager>

      <!-- DAO interfaces and implementations should be listed here -->
      <dao interface="test.dao.MyTableDAO" implementation="test.dao.MyTableDAOImpl" />
   </context>
	
</daoConfig>

NOTE − यह कदम केवल तभी आवश्यक है जब आप iBATIS DAO ढांचे के लिए DAO उत्पन्न करते हैं।

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved