JasperReports এবং Database Integration

JasperReports এর সাথে ডাটাবেস ইন্টিগ্রেশন একটি গুরুত্বপূর্ণ ফিচার, যা আপনাকে আপনার ডাটাবেসের ডেটা ব্যবহার করে ডাইনামিক রিপোর্ট তৈরি করতে সক্ষম করে। JasperReports ব্যবহার করে আপনি SQL কুয়েরি চালাতে পারেন, ডাটাবেস থেকে ডেটা নিয়ে রিপোর্টে ব্যবহার করতে পারেন এবং সেই রিপোর্টটি পিডিএফ, এক্সেল, বা অন্যান্য ফরম্যাটে এক্সপোর্ট করতে পারেন।

JasperReports সাধারণত JDBC, JPA, Hibernate বা অন্যান্য ORM (Object-Relational Mapping) টুলের মাধ্যমে ডেটাবেসে সংযোগ স্থাপন করে ডেটা এক্সট্র্যাক্ট করে রিপোর্ট তৈরি করতে সক্ষম।

JasperReports এবং Database Integration এর প্রাথমিক পদক্ষেপ

1. ডাটাবেস কানেকশন সেটআপ: JasperReports-এ ডেটা সোর্স কানেকশন করতে হবে, যাতে ডেটাবেসের তথ্য পাওয়া যায়।
2. SQL কুয়েরি ব্যবহার: ডাটাবেস থেকে ডেটা ফেচ করার জন্য SQL কুয়েরি বা প্যারামেটারাইজড কুয়েরি ব্যবহার করতে হবে।
3. Report Design (JRXML): JRXML ফাইলের মাধ্যমে রিপোর্ট ডিজাইন করা হয়, যেখানে ডাটাবেসের ডেটা ব্যবহৃত হয়।
4. Report Generation: ডেটা পাস করার পর, রিপোর্ট তৈরি এবং এক্সপোর্ট করা হয় (যেমন PDF, Excel, CSV ইত্যাদি)।

JasperReports-এ Database Integration-এর উদাহরণ

ধাপ ১: JDBC DataSource সেটআপ

JasperReports ডাটাবেসের সাথে সংযোগ স্থাপনের জন্য JDBC DataSource ব্যবহার করে ডেটাবেস কানেকশন তৈরি করা যায়। আপনি ডাটাবেস কনফিগারেশন এবং SQL কুয়েরি ব্যবহার করে ডেটা সংগ্রহ করবেন।

pom.xml (Maven Dependency):

<dependency>
    <groupId>net.sf.jasperreports</groupId>
    <artifactId>jasperreports</artifactId>
    <version>6.17.0</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.25</version>
</dependency>

এখানে mysql-connector-java ডিপেনডেন্সি দেওয়া হয়েছে, যা MySQL ডাটাবেসের সাথে সংযোগ স্থাপন করতে ব্যবহৃত হবে।

ধাপ ২: JasperReports JRXML ফাইল তৈরি করা

JRXML ফাইলটি সেই রিপোর্টের টেমপ্লেট, যেখানে আপনি SQL কুয়েরি, parameters, fields, এবং columns যোগ করবেন। নিচে একটি উদাহরণ দেওয়া হল যেখানে ডাটাবেস থেকে ডেটা এনে রিপোর্ট তৈরি করা হচ্ছে।

Example JRXML file (report.jrxml):

<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" 
              name="SalesReport" pageWidth="595" pageHeight="842" columnWidth="515">
    <parameter name="startDate" class="java.util.Date"/>
    <parameter name="endDate" class="java.util.Date"/>
    
    <queryString>
        <![CDATA[
        SELECT product_name, sales_amount, sale_date 
        FROM sales 
        WHERE sale_date BETWEEN $P{startDate} AND $P{endDate}
        ORDER BY sale_date
        ]]>
    </queryString>

    <field name="product_name" class="java.lang.String"/>
    <field name="sales_amount" class="java.lang.Double"/>
    <field name="sale_date" class="java.util.Date"/>

    <detail>
        <band height="20">
            <textField>
                <reportElement x="0" y="0" width="200" height="30"/>
                <textFieldExpression><![CDATA[$F{product_name}]]></textFieldExpression>
            </textField>
            <textField>
                <reportElement x="200" y="0" width="150" height="30"/>
                <textFieldExpression><![CDATA[$F{sales_amount}]]></textFieldExpression>
            </textField>
            <textField>
                <reportElement x="350" y="0" width="150" height="30"/>
                <textFieldExpression><![CDATA[$F{sale_date}]]></textFieldExpression>
            </textField>
        </band>
    </detail>
</jasperReport>

এখানে:

• queryString-এ একটি SQL কুয়েরি ব্যবহার করা হয়েছে, যা ডাটাবেস থেকে sales টেবিলের ডেটা সংগ্রহ করবে। এখানে startDate এবং endDate প্যারামিটার ব্যবহার করা হয়েছে।
• field এলিমেন্টগুলোতে ডেটাবেস ফিল্ড যেমন product_name, sales_amount, এবং sale_date ব্যবহার করা হয়েছে।

ধাপ ৩: Java কোডে রিপোর্ট পূর্ণ করা

Java কোড ব্যবহার করে JasperReports রিপোর্ট পূর্ণ করা এবং PDF ফরম্যাটে এক্সপোর্ট করা হয়।

import net.sf.jasperreports.engine.*;
import java.util.HashMap;
import java.util.Map;
import java.sql.Connection;
import java.sql.DriverManager;

public class JasperReportsDatabaseExample {
    public static void main(String[] args) throws Exception {
        // Database connection setup
        String jdbcUrl = "jdbc:mysql://localhost:3306/your_database";
        String jdbcUser = "root";
        String jdbcPassword = "password";
        
        Connection connection = DriverManager.getConnection(jdbcUrl, jdbcUser, jdbcPassword);

        // Parameters for the report
        Map<String, Object> parameters = new HashMap<>();
        parameters.put("startDate", "2022-01-01");
        parameters.put("endDate", "2022-12-31");

        // Compile the report
        JasperReport jasperReport = JasperCompileManager.compileReport("report.jrxml");

        // Fill the report with data
        JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, parameters, connection);

        // Export the report to PDF
        JasperExportManager.exportReportToPdfFile(jasperPrint, "sales_report.pdf");

        // Close the database connection
        connection.close();
    }
}

এখানে:

• Connection: MySQL ডাটাবেসের সাথে JDBC সংযোগ স্থাপন করা হয়েছে।
• Parameters: রিপোর্টে প্যারামিটার হিসেবে startDate এবং endDate পাস করা হয়েছে।
• JasperFillManager.fillReport(): এই মেথডে রিপোর্টের প্যারামিটার এবং ডেটাবেস কানেকশন পাস করা হয়েছে।
• JasperExportManager.exportReportToPdfFile(): রিপোর্টটি PDF ফরম্যাটে এক্সপোর্ট করা হয়েছে।

ধাপ ৪: JasperReports PDF আউটপুট

এই কোডটি চালানোর পর, ডাটাবেস থেকে নির্দিষ্ট তারিখের মধ্যে বিক্রয়ের ডেটা নিয়ে একটি PDF রিপোর্ট তৈরি হবে, যা sales_report.pdf নামে আউটপুট হবে।

JasperReports এবং Database Integration এর সুবিধা

1. Dynamic Report Generation:
   • JasperReports ডেটাবেস থেকে ডাইনামিক ডেটা নিয়ে রিপোর্ট তৈরি করতে সক্ষম। SQL কুয়েরি ব্যবহার করে ব্যবহারকারীকে প্যারামিটার পাস করা হয় এবং রিপোর্টের কনটেন্ট তৈরি করা হয়।
2. Multiple Data Sources:
   • JasperReports বিভিন্ন ধরনের ডেটা সোর্স (JDBC, JPA, XML, CSV ইত্যাদি) থেকে ডেটা সংগ্রহ করতে সক্ষম, যা ব্যবসার জন্য আরও কার্যকর।
3. Custom SQL Queries:
   • JasperReports কাস্টম SQL কুয়েরি ব্যবহার করে ডেটাবেস থেকে তথ্য সংগ্রহ করতে পারে। ডেটাবেসের সাথে এক্সপ্রেসিভ কুয়েরি রাইটিংও সম্ভব।
4. Seamless Integration with Java-based Applications:
   • JasperReports Java-based অ্যাপ্লিকেশনগুলির সাথে সহজেই ইন্টিগ্রেট করা যায়। ডাটাবেস থেকে ডেটা সংগ্রহ এবং তা রিপোটে ফিল করার প্রক্রিয়া সরাসরি Java কোডে করা যায়।
5. Multi-format Output:
   • JasperReports তৈরি করা রিপোর্টকে একাধিক ফরম্যাটে এক্সপোর্ট করতে পারে, যেমন PDF, Excel, HTML, CSV ইত্যাদি, যা বিভিন্ন প্রয়োজনে ব্যবহৃত হয়।

JasperReports এবং ডাটাবেস ইন্টিগ্রেশন আপনাকে ডাটাবেস থেকে ডাইনামিক ডেটা নিয়ে শক্তিশালী রিপোর্ট তৈরি করতে সক্ষম করে। SQL কুয়েরি, প্যারামিটারাইজড কুয়েরি, এবং JPA/JDBC ডেটাবেস কানেকশন ব্যবহার করে JasperReports সহজেই ডেটাবেসের ডেটা নিয়ে রিপোর্ট তৈরি এবং এক্সপোর্ট করতে পারে। Java EE বা Spring প্রজেক্টে JasperReports ব্যবহার করে আপনি কাস্টম রিপোর্ট তৈরি করতে পারেন এবং সেগুলো পিডিএফ, এক্সেল, বা অন্যান্য ফরম্যাটে এক্সপোর্ট করতে পারেন।

JasperReports এ JDBC DataSource ব্যবহার করে রিপোর্ট তৈরি করা খুবই সাধারণ এবং কার্যকরী একটি প্রক্রিয়া, যেখানে আপনি JDBC (Java Database Connectivity) ব্যবহার করে ডেটাবেস থেকে ডেটা নিয়ে রিপোর্ট তৈরি করেন। এই প্রক্রিয়ায়, JasperReports আপনার ডেটাবেস থেকে ডেটা নিয়ে একটি JRXML ফাইলকে রিপোর্ট আউটপুট ফরম্যাটে রেন্ডার করে (যেমন PDF, HTML, CSV ইত্যাদি)।

JDBC DataSource ব্যবহার করে আপনি যেকোনো রিলেশনাল ডেটাবেস যেমন MySQL, PostgreSQL, Oracle ইত্যাদি থেকে ডেটা সংগ্রহ করতে পারেন এবং তা রিপোর্টে উপস্থাপন করতে পারেন।

JDBC DataSource ব্যবহার করে JasperReports রিপোর্ট তৈরি করার প্রক্রিয়া

1. JDBC Connection তৈরি করা:
   • প্রথমে, আপনাকে একটি JDBC Connection তৈরি করতে হবে যা ডেটাবেসের সাথে সংযোগ করবে।
2. JRXML ফাইল তৈরি করা:
   • তারপর, একটি JRXML ফাইল তৈরি করতে হবে যেখানে রিপোর্টের ডেটা, লেআউট, ফরম্যাট ইত্যাদি নির্ধারণ করা হবে।
3. ডেটা সংগ্রহ এবং রিপোর্ট ফিলিং:
   • JDBC ডেটা সোর্স ব্যবহার করে ডেটাবেস থেকে ডেটা সংগ্রহ করা হবে এবং তারপর এটি রিপোর্টে পূর্ণ করা হবে।
4. রিপোর্ট এক্সপোর্ট করা:
   • রিপোর্টটি শেষে কাঙ্ক্ষিত ফরম্যাটে এক্সপোর্ট করা হবে (যেমন PDF, Excel ইত্যাদি)।

ধাপ ১: JDBC DataSource তৈরি এবং ডেটাবেস সংযোগ

আপনি JDBC ব্যবহার করে ডেটাবেসে সংযোগ করতে পারেন। এখানে একটি MySQL ডেটাবেসের উদাহরণ দেওয়া হলো।

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class JDBCDataSource {
    public static Connection getConnection() throws SQLException {
        // MySQL JDBC URL, username, password
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String username = "root";
        String password = "password";

        // JDBC Connection তৈরি করা
        return DriverManager.getConnection(url, username, password);
    }
}

এখানে, DriverManager ব্যবহার করে MySQL ডেটাবেসের সাথে সংযোগ করা হয়েছে।

ধাপ ২: JRXML ফাইল তৈরি করা

JRXML ফাইল হলো JasperReports এর টেমপ্লেট যা XML ফরম্যাটে রিপোর্টের লেআউট এবং ডেটা নির্ধারণ করে। এখানে একটি উদাহরণ দেওয়া হলো যেখানে JDBC ডেটাবেস থেকে ডেটা ফিল্ড আনা হয়েছে:

<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports
                                  http://jasperreports.sourceforge.net/xsd/jasperreport.xsd"
              name="userReport" language="java" pageWidth="595" pageHeight="842">

    <!-- ডেটা সোর্স এবং কুয়েরি -->
    <queryString>
        <![CDATA[SELECT id, name, email FROM users]]>
    </queryString>

    <field name="id" class="java.lang.Integer"/>
    <field name="name" class="java.lang.String"/>
    <field name="email" class="java.lang.String"/>

    <!-- রিপোর্ট ডিজাইন -->
    <detail>
        <band height="20">
            <textField>
                <reportElement x="0" y="0" width="50" height="20"/>
                <textFieldExpression><![CDATA[$F{id}]]></textFieldExpression>
            </textField>
            <textField>
                <reportElement x="50" y="0" width="200" height="20"/>
                <textFieldExpression><![CDATA[$F{name}]]></textFieldExpression>
            </textField>
            <textField>
                <reportElement x="250" y="0" width="250" height="20"/>
                <textFieldExpression><![CDATA[$F{email}]]></textFieldExpression>
            </textField>
        </band>
    </detail>

</jasperReport>

এখানে, queryString ট্যাগে SQL কুয়েরি লেখা হয়েছে, যা users টেবিল থেকে id, name, এবং email কলামগুলোর ডেটা সংগ্রহ করবে।

ধাপ ৩: ডেটা সংগ্রহ এবং রিপোর্ট ফিলিং

রিপোর্টটি তৈরি করার জন্য JasperFillManager ব্যবহার করে ডেটাবেস থেকে ডেটা ফিল করা হবে।

import net.sf.jasperreports.engine.*;
import java.sql.Connection;
import java.util.HashMap;

public class ReportGenerator {
    public static void main(String[] args) {
        try {
            // JRXML ফাইল থেকে রিপোর্ট তৈরি করা
            String reportPath = "path/to/your/jasperreport.jrxml";
            JasperReport jasperReport = JasperCompileManager.compileReport(reportPath);

            // JDBC ডেটা সোর্স থেকে ডেটা সংগ্রহ
            Connection connection = JDBCDataSource.getConnection();

            // প্যারামিটার (যদি থাকে)
            HashMap<String, Object> parameters = new HashMap<>();
            parameters.put("ReportTitle", "User Report");

            // রিপোর্ট ফিলিং (ডেটা সঙ্গে)
            JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, parameters, connection);

            // রিপোর্ট এক্সপোর্ট করা
            JasperExportManager.exportReportToPdfFile(jasperPrint, "user_report.pdf");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

এখানে:

1. JasperCompileManager.compileReport() ব্যবহার করে JRXML ফাইল কম্পাইল করা হচ্ছে।
2. JDBCDataSource.getConnection() ব্যবহার করে ডেটাবেস সংযোগ করা হচ্ছে।
3. JasperFillManager.fillReport() ব্যবহার করে রিপোর্টে ডেটা ফিল করা হচ্ছে।
4. JasperExportManager.exportReportToPdfFile() ব্যবহার করে রিপোর্টকে PDF ফরম্যাটে এক্সপোর্ট করা হচ্ছে।

ধাপ ৪: রিপোর্ট এক্সপোর্ট করা

JasperReports বিভিন্ন ফরম্যাটে রিপোর্ট এক্সপোর্ট করতে সক্ষম। আপনি PDF, Excel, HTML, CSV ইত্যাদি ফরম্যাটে রিপোর্ট এক্সপোর্ট করতে পারেন।

PDF Example:

JasperExportManager.exportReportToPdfFile(jasperPrint, "user_report.pdf");

Excel (XLS) Example:

JRXlsExporter exporter = new JRXlsExporter();
exporter.setExporterInput(new SimpleExporterInput(jasperPrint));
exporter.setExporterOutput(new SimpleOutputStreamExporterOutput("user_report.xlsx"));
exporter.exportReport();

1. JDBC DataSource ব্যবহার করে JasperReports আপনাকে ডেটাবেস থেকে ডেটা নিয়ে রিপোর্ট তৈরি করার সুবিধা দেয়।
2. JRXML ফাইলের মাধ্যমে রিপোর্টের ডিজাইন এবং লেআউট কনফিগার করা হয়।
3. JasperReports এর মাধ্যমে আপনি সহজেই ডেটাবেস ডেটাকে PDF, Excel, HTML, CSV ফরম্যাটে এক্সপোর্ট করতে পারেন।
4. JasperReports ব্যবহার করে Java EE অ্যাপ্লিকেশনগুলিতে ডাইনামিক এবং কাস্টম রিপোর্টিং সিস্টেম তৈরি করা যেতে পারে, যা প্রোডাক্টিভিটি এবং ডেটা বিশ্লেষণকে আরও সহজ এবং কার্যকরী করে তোলে।

JasperReports হল একটি শক্তিশালী ওপেন সোর্স রিপোর্টিং টুল যা Java অ্যাপ্লিকেশন থেকে রিপোর্ট তৈরি করতে ব্যবহৃত হয়। JDBC DataSource ব্যবহার করে রিপোর্ট তৈরি করার সময়, আপনি ডেটাবেস থেকে তথ্য আনার জন্য SQL Queries অথবা Stored Procedures ব্যবহার করতে পারেন। এই টুলটি খুবই কার্যকরী যখন আপনাকে ডেটাবেসে সংরক্ষিত তথ্য ভিত্তিক রিপোর্ট তৈরি করতে হয়।

SQL Queries এবং Stored Procedures ব্যবহার করে JasperReports এ রিপোর্ট তৈরি করা

১. JDBC DataSource ব্যবহার করে রিপোর্ট তৈরি করা

JasperReports ডেটাবেস থেকে রিপোর্ট তৈরি করতে JDBC DataSource ব্যবহার করে ডেটা বের করার জন্য SQL Queries ব্যবহার করতে পারে। ডেটাবেসের সাথে সংযোগ স্থাপনের জন্য JDBC ড্রাইভার এবং ডেটাবেস ক্রেডেনশিয়ালস প্রয়োজন হয়। একটি সাধারণ JDBC DataSource দিয়ে JasperReports এর রিপোর্ট তৈরি করা যায়।

JDBC DataSource কনফিগারেশন:

প্রথমে আপনাকে JDBC ড্রাইভার এবং ডেটাবেস কনফিগারেশন করতে হবে। যদি আপনি MySQL ব্যবহার করেন, তবে আপনি JDBC URL, username, এবং password ব্যবহার করে ডেটাবেসে সংযোগ করতে পারেন।

import javax.sql.DataSource;
import com.mysql.cj.jdbc.MysqlDataSource;

public class DataSourceConfig {
    public static DataSource getDataSource() {
        MysqlDataSource dataSource = new MysqlDataSource();
        dataSource.setURL("jdbc:mysql://localhost:3306/your_database");
        dataSource.setUser("username");
        dataSource.setPassword("password");
        return dataSource;
    }
}

এখন, আপনি JasperReports এ DataSource হিসেবে এই কনফিগারেশন ব্যবহার করতে পারবেন।

২. SQL Query ব্যবহার করে রিপোর্ট তৈরি করা

JasperReports এ রিপোর্ট তৈরি করার জন্য সাধারণত JRXML ফাইল তৈরি করা হয়, যেখানে আপনি ডেটাবেসের তথ্য SQL Query এর মাধ্যমে সংগ্রহ করেন।

JRXML ফাইলের মধ্যে SQL Query লেখা হয় যা ডেটাবেস থেকে তথ্য সংগ্রহ করে এবং সেই ডেটা রিপোর্টে প্রদর্শিত হয়।

SQL Query Example:

<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports
                                  http://jasperreports.sourceforge.net/xsd/jasperreport.xsd"
              name="SalesReport" language="java" pageWidth="595" pageHeight="842">

    <queryString>
        <![CDATA[SELECT id, product_name, price, quantity FROM sales]]>
    </queryString>

    <field name="id" class="java.lang.Integer"/>
    <field name="product_name" class="java.lang.String"/>
    <field name="price" class="java.lang.Double"/>
    <field name="quantity" class="java.lang.Integer"/>

    <detail>
        <band height="20">
            <textField>
                <reportElement x="0" y="0" width="100" height="20"/>
                <textFieldExpression><![CDATA[$F{id}]]></textFieldExpression>
            </textField>
            <textField>
                <reportElement x="100" y="0" width="200" height="20"/>
                <textFieldExpression><![CDATA[$F{product_name}]]></textFieldExpression>
            </textField>
            <textField>
                <reportElement x="300" y="0" width="100" height="20"/>
                <textFieldExpression><![CDATA[$F{price}]]></textFieldExpression>
            </textField>
            <textField>
                <reportElement x="400" y="0" width="100" height="20"/>
                <textFieldExpression><![CDATA[$F{quantity}]]></textFieldExpression>
            </textField>
        </band>
    </detail>

</jasperReport>

এখানে, <queryString> ট্যাগে SQL কুয়েরি ব্যবহার করা হয়েছে যা sales টেবিল থেকে পণ্য আইডি, নাম, মূল্য এবং পরিমাণের তথ্য নিয়ে আসবে। এই ডেটা $F{field_name} ব্যবহার করে রিপোর্টের বিভিন্ন ফিল্ডে প্রদর্শিত হবে।

Java Code Example (JDBC DataSource দিয়ে রিপোর্ট ফিল করা):

import net.sf.jasperreports.engine.*;
import javax.sql.DataSource;
import java.util.HashMap;
import java.sql.Connection;

public class JasperReportsJDBCExample {
    public static void main(String[] args) throws JRException {
        // JDBC DataSource কনফিগারেশন
        DataSource dataSource = DataSourceConfig.getDataSource();

        // ডেটাবেস সংযোগ
        try (Connection connection = dataSource.getConnection()) {
            // JRXML ফাইল থেকে রিপোর্ট তৈরি
            JasperReport jasperReport = JasperCompileManager.compileReport("path/to/your/report.jrxml");

            // রিপোর্টে প্যারামিটার পাঠানো
            HashMap<String, Object> parameters = new HashMap<>();
            parameters.put("ReportTitle", "Sales Report");

            // রিপোর্ট ফিলিং
            JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, parameters, connection);

            // রিপোর্ট পিডিএফ আউটপুট
            JasperExportManager.exportReportToPdfFile(jasperPrint, "sales_report.pdf");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

এই কোডের মাধ্যমে:

1. JDBC Connection ব্যবহৃত হয়েছে রিপোর্টের জন্য।
2. JasperCompileManager দিয়ে JRXML ফাইল কম্পাইল করা হয়েছে।
3. JasperFillManager দিয়ে ডেটাবেস থেকে ডেটা নিয়ে রিপোর্ট ফিল করা হয়েছে।
4. JasperExportManager দিয়ে রিপোর্ট PDF ফরম্যাটে এক্সপোর্ট করা হয়েছে।

৩. Stored Procedures ব্যবহার করে রিপোর্ট তৈরি করা

Stored Procedures হল ডেটাবেসে সংরক্ষিত SQL কোড যা একটি নির্দিষ্ট কাজ সম্পাদন করে, যেমন ডেটা প্রসেস করা বা কিছু গণনা করা। JasperReports এ Stored Procedures ব্যবহার করে রিপোর্ট তৈরি করা সম্ভব। এই ক্ষেত্রে, আপনি Stored Procedure এর আউটপুট হিসেবে ডেটা পান এবং তা রিপোর্টে প্রদর্শন করেন।

Stored Procedure Example:

ধরা যাক, আপনার ডেটাবেসে একটি Stored Procedure রয়েছে যেটি sales_summary নামে পরিচিত এবং এটি সমস্ত পণ্যের মোট বিক্রয় প্রাপ্ত তথ্য প্রদান করে।

CREATE PROCEDURE getSalesSummary()
BEGIN
    SELECT product_name, SUM(quantity * price) AS total_sales
    FROM sales
    GROUP BY product_name;
END;

JRXML ফাইলের মাধ্যমে Stored Procedure কল করা:

<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports
                                  http://jasperreports.sourceforge.net/xsd/jasperreport.xsd"
              name="SalesSummaryReport" language="java" pageWidth="595" pageHeight="842">

    <queryString>
        <![CDATA[{call getSalesSummary()}]]>
    </queryString>

    <field name="product_name" class="java.lang.String"/>
    <field name="total_sales" class="java.lang.Double"/>

    <detail>
        <band height="20">
            <textField>
                <reportElement x="0" y="0" width="300" height="20"/>
                <textFieldExpression><![CDATA[$F{product_name}]]></textFieldExpression>
            </textField>
            <textField>
                <reportElement x="300" y="0" width="200" height="20"/>
                <textFieldExpression><![CDATA[$F{total_sales}]]></textFieldExpression>
            </textField>
        </band>
    </detail>

</jasperReport>

Java Code Example (Stored Procedure ব্যবহার করা):

import net.sf.jasperreports.engine.*;
import javax.sql.DataSource;
import java.util.HashMap;
import java.sql.Connection;
import java.sql.CallableStatement;

public class JasperReportsStoredProcedureExample {
    public static void main(String[] args) throws JRException {
        // JDBC DataSource কনফিগারেশন
        DataSource dataSource = DataSourceConfig.getDataSource();

        // ডেটাবেস সংযোগ
        try (Connection connection = dataSource.getConnection()) {
            // Stored Procedure কল করা
            CallableStatement statement = connection.prepareCall("{call getSalesSummary()}");
            statement.execute();

            // JRXML ফাইল থেকে রিপোর্ট তৈরি
            JasperReport jasperReport = JasperCompileManager.compileReport("path/to/your/report.jrxml");

            // রিপোর্ট ফিলিং
            JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, new HashMap<>(), connection);

            // রিপোর্ট পিডিএফ আউটপুট
            JasperExportManager.exportReportToPdfFile(jasperPrint, "sales_summary_report.pdf");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

1. SQL Queries এবং Stored Procedures ব্যবহার করে JasperReports এর মাধ্যমে ডেটাবেস থেকে ডেটা নিয়ে রিপোর্ট তৈরি করা যায়।
2. SQL Query ব্যবহার করে সরাসরি ডেটাবেস থেকে ডেটা সংগ্রহ করা হয়, এবং Stored Procedure ব্যবহার করে আপনি পূর্বনির্ধারিত SQL প্রক্রিয়া থেকে আউটপুট পেতে পারেন।
3. JDBC DataSource ব্যবহার করে আপনি JasperReports এর রিপোর্ট ফিলিং করতে পারেন, যেখানে JasperFillManager এবং JasperExportManager দিয়ে রিপোর্ট এক্সপোর্ট করা হয়।

এইভাবে আপনি JasperReports-এর সাহায্যে ডেটাবেস থেকে SQL Queries অথবা Stored Procedures ব্যবহার করে রিপোর্ট তৈরি, কাস্টমাইজ এবং এক্সপোর্ট করতে পারেন।

JasperReports-এ multiple database sources থেকে ডেটা ফেচ করা একটি সাধারণ এবং শক্তিশালী ফিচার। এটি আপনাকে একাধিক ডেটাবেস, টেবিল বা JDBC সোর্স থেকে ডেটা একত্রিত করতে সাহায্য করে। আপনি বিভিন্ন ডেটাবেস বা ডেটাসোর্সে কোয়েরি চালিয়ে সেগুলোর ফলাফল রিপোর্টে মিশিয়ে দেখাতে পারেন।

Multiple Data Sources এর উদ্দেশ্য:

• একাধিক ডেটাবেস সংযোগ থেকে ডেটা প্রাপ্তি।
• Joins করতে না পারলে আলাদা আলাদা ডেটাসোর্স থেকে ডেটা ফেচ করা।
• একাধিক টেবিল বা ভিউ থেকে রিপোর্ট তৈরি করা।
• কোডের মাধ্যমে বিভিন্ন সোর্স থেকে ডেটা একত্রিত করা।

এই উদাহরণে, আমরা দুটি আলাদা ডেটাবেস থেকে ডেটা ফেচ করব এবং সেগুলোর সাথে JasperReports ব্যবহার করে রিপোর্ট তৈরি করব।

ধাপ ১: Multiple Data Sources তৈরি করা

আমরা দুটি ডেটাবেস সিমুলেট করব: একটি Employee Database এবং একটি Department Database। এই ডেটাবেসগুলো থেকে আমরা ডেটা JDBC এর মাধ্যমে জিজ্ঞাসা করব।

1.1. Employee Database

ডেটাবেসের জন্য একটি টেবিল হতে পারে যা কর্মচারীদের তথ্য সংরক্ষণ করে:

1.2. Department Database

একটি আলাদা ডেটাবেস হতে পারে যেখানে Department তথ্য রাখা হবে:

ধাপ ২: JDBC DataSource ব্যবহার করা

আমরা JDBC ব্যবহার করে Employee এবং Department ডেটাবেসের জন্য ডেটা সোর্স তৈরি করব।

2.1. DataSource Configuration

import javax.sql.DataSource;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

public class DataSourceConfig {

    public static DataSource getEmployeeDataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/employee_db");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        return dataSource;
    }

    public static DataSource getDepartmentDataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/department_db");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        return dataSource;
    }
}

এখানে আমরা Employee Database এবং Department Database এর জন্য দুটি আলাদা DataSource তৈরি করেছি।

ধাপ ৩: JasperReports Configuration

এখন, আমরা JasperReports এর মাধ্যমে দুটি আলাদা ডেটাবেস থেকে ডেটা একত্রিত করব এবং সেগুলো রিপোর্টে প্রক্রিয়া করব।

3.1. Report Design (JRXML)

আমরা Employee এবং Department এর ডেটাকে একত্রিত করতে চাই, যেখানে Employee এর জন্য EmployeeID, Name, এবং DepartmentID থাকবে এবং Department এর জন্য DepartmentID এবং DepartmentName থাকবে।

<?xml version="1.0" encoding="UTF-8"?>
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports 
                                  http://jasperreports.sourceforge.net/xsd/jasperreport.xsd"
              name="EmployeeDepartmentReport" pageWidth="595" pageHeight="842" columnWidth="555" leftMargin="20" rightMargin="20" topMargin="20" bottomMargin="20">

    <!-- Employee Fields -->
    <field name="EmployeeID" class="java.lang.Integer"/>
    <field name="Name" class="java.lang.String"/>
    <field name="DepartmentID" class="java.lang.Integer"/>
    <field name="DepartmentName" class="java.lang.String"/>

    <!-- SQL Query for Employee Data -->
    <queryString>
        <![CDATA[SELECT EmployeeID, Name, DepartmentID FROM Employees]]>
    </queryString>

    <!-- SQL Query for Department Data -->
    <subDataset name="DepartmentData">
        <queryString>
            <![CDATA[SELECT DepartmentID, DepartmentName FROM Departments]]>
        </queryString>
    </subDataset>

    <detail>
        <band height="20">
            <textField>
                <reportElement x="0" y="0" width="50" height="20"/>
                <textFieldExpression><![CDATA[$F{EmployeeID}]]></textFieldExpression>
            </textField>
            <textField>
                <reportElement x="60" y="0" width="200" height="20"/>
                <textFieldExpression><![CDATA[$F{Name}]]></textFieldExpression>
            </textField>
            <textField>
                <reportElement x="270" y="0" width="100" height="20"/>
                <textFieldExpression><![CDATA[$F{DepartmentID}]]></textFieldExpression>
            </textField>

            <!-- Subreport for Department Name -->
            <subreport>
                <reportElement x="380" y="0" width="150" height="20"/>
                <subreportExpression><![CDATA["DepartmentReport.jasper"]]></subreportExpression>
                <dataSourceExpression><![CDATA[$F{DepartmentID}]]></dataSourceExpression>
            </subreport>
        </band>
    </detail>
</jasperReport>

ব্যাখ্যা:

• Main Query: Employee ডেটাবেস থেকে কর্মচারীদের তথ্য নিয়ে আসছে।
• Subreport (Department): Department ডেটাবেসের ডেটা subreport এর মাধ্যমে অন্তর্ভুক্ত করা হচ্ছে।

ধাপ ৪: Java কোড দিয়ে Multiple DataSources থেকে Data Fetch এবং Report Generate করা

Java কোডের মাধ্যমে আমরা দুইটি ডেটাবেস সোর্সের ডেটা ফেচ করব এবং সেই ডেটার ভিত্তিতে রিপোর্ট তৈরি করবো।

4.1. Java কোড

import net.sf.jasperreports.engine.*;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;

import java.util.*;

public class MultipleDatabaseSourceReport {
    public static void main(String[] args) {
        try {
            // Employee and Department Data Fetch (Simulated)
            List<Employee> employeeList = fetchEmployeeData();
            List<Department> departmentList = fetchDepartmentData();

            // JRBeanCollectionDataSource for Employee and Department Data
            JRBeanCollectionDataSource employeeDataSource = new JRBeanCollectionDataSource(employeeList);
            JRBeanCollectionDataSource departmentDataSource = new JRBeanCollectionDataSource(departmentList);

            // Compile the main report and subreport
            JasperReport mainReport = JasperCompileManager.compileReport("EmployeeDepartmentReport.jrxml");

            // Parameters for the report
            Map<String, Object> parameters = new HashMap<>();
            parameters.put("EmployeeDataSource", employeeDataSource);
            parameters.put("DepartmentDataSource", departmentDataSource);

            // Fill the report
            JasperPrint jasperPrint = JasperFillManager.fillReport(mainReport, parameters, new JREmptyDataSource());

            // Export the report to PDF
            JasperExportManager.exportReportToPdfFile(jasperPrint, "EmployeeDepartmentReport.pdf");

            System.out.println("Report Generated Successfully!");
        } catch (JRException e) {
            e.printStackTrace();
        }
    }

    // Simulate fetching Employee data from the Employee Database
    private static List<Employee> fetchEmployeeData() {
        List<Employee> employees = new ArrayList<>();
        employees.add(new Employee(1, "John Doe", 101));
        employees.add(new Employee(2, "Jane Smith", 102));
        return employees;
    }

    // Simulate fetching Department data from the Department Database
    private static List<Department> fetchDepartmentData() {
        List<Department> departments = new ArrayList<>();
        departments.add(new Department(101, "HR"));
        departments.add(new Department(102, "Finance"));
        return departments;
    }
}

Explanation:

1. Data Fetching: এখানে আমরা Employee এবং Department ডেটা ফেচ করেছি।
2. JRBeanCollectionDataSource: Employee এবং Department ডেটার জন্য আলাদা আলাদা JRBeanCollectionDataSource তৈরি করা হয়েছে।
3. Report Compilation and Filling: রিপোর্টের কম্পাইল এবং পূর্ণকরণের মাধ্যমে মূল রিপোর্ট এবং subreport এর ডেটা মাপা হয়েছে।
4. Report Export: রিপোর্টটি PDF ফরম্যাটে এক্সপোর্ট করা হয়েছে।

• JasperReports আপনাকে multiple database sources থেকে ডেটা ফেচ করতে এবং subreports ব্যবহার করে ডেটা একত্রিত করতে সহায়তা করে।
• আপনি multiple datasets ব্যবহার করে একাধিক ডেটাবেস বা ডেটা সোর্স থেকে রিপোর্ট তৈরি করতে পারেন।
• JasperReports এ JRXML ফাইল তৈরি করতে এবং JDBC বা JRBeanCollectionDataSource এর মাধ্যমে ডেটা ফেচ করা যায়।

এটি একটি প্রাথমিক উদাহরণ ছিল যেখানে multiple database sources থেকে ডেটা একত্রিত করে JasperReports রিপোর্ট তৈরি করা হয়েছে।

JasperReports একটি জনপ্রিয় রিপোর্টিং লাইব্রেরি যা Java অ্যাপ্লিকেশন থেকে রিপোর্ট তৈরি করতে ব্যবহৃত হয়। এটি একটি ডেটাবেস থেকে ডেটা নিয়ে রিপোর্ট তৈরি করতে পারে এবং JDBC এর মাধ্যমে বিভিন্ন ডেটাবেসের সঙ্গে সংযোগ স্থাপন করে ডেটা ফেচ করে। তবে যখন রিপোর্ট তৈরির জন্য বারবার ডেটাবেস সংযোগের প্রয়োজন হয়, তখন Connection Pooling এবং Transaction Management অত্যন্ত গুরুত্বপূর্ণ হয়ে ওঠে। এই দুটি কনসেপ্ট রিপোর্টিং প্রসেসকে আরও দ্রুত এবং দক্ষ করে তোলে।

1. Database Connection Pooling

Connection Pooling হল একটি প্রযুক্তি যার মাধ্যমে একটি ডেটাবেস সংযোগের জন্য নতুন সংযোগ তৈরির পরিবর্তে পুনঃব্যবহৃত সংযোগগুলি রাখা হয়। এটি performance optimization এবং resource management এর জন্য ব্যবহৃত হয়। বিশেষ করে JasperReports-এর মতো রিপোর্টিং টুলগুলোর ক্ষেত্রে যখন একাধিক রিপোর্ট তৈরি করতে হয়, তখন এটি database connection overhead কমিয়ে আনে এবং response time দ্রুত করে।

JDBC Connection Pooling-এর মাধ্যমে JasperReports Database Connection

JasperReports ডেটাবেসের সঙ্গে JDBC সংযোগের জন্য DataSource ব্যবহার করে। একটি Connection Pool ব্যবহার করে আপনি একাধিক রিপোর্টের জন্য ডেটাবেস সংযোগকে পুনরায় ব্যবহার করতে পারেন, যা অ্যাপ্লিকেশনকে দ্রুত এবং আরও দক্ষ করে তোলে।

Example: Using HikariCP for Database Connection Pooling

HikariCP হল একটি জনপ্রিয় JDBC connection pool লাইব্রেরি যা খুব দ্রুত এবং কার্যকরী। নিচে HikariCP এবং JasperReports এর মাধ্যমে ডেটাবেস সংযোগের pool কনফিগার করা হচ্ছে।

1. Maven Dependency for HikariCP: প্রথমে HikariCP লাইব্রেরিটি আপনার pom.xml-এ যোগ করুন।

   <dependency>
       <groupId>com.zaxxer</groupId>
       <artifactId>HikariCP</artifactId>
       <version>5.0.1</version>
   </dependency>
   

2. Configure HikariCP Connection Pool: এখানে, HikariCP ব্যবহার করে ডেটাবেস সংযোগ pool কনফিগার করা হচ্ছে।

   import com.zaxxer.hikari.HikariConfig;
   import com.zaxxer.hikari.HikariDataSource;
   
   public class DatabaseConnectionPool {
       private static HikariDataSource dataSource;
   
       static {
           HikariConfig config = new HikariConfig();
           config.setJdbcUrl("jdbc:mysql://localhost:3306/mydatabase");
           config.setUsername("username");
           config.setPassword("password");
           config.setMaximumPoolSize(10); // maximum number of connections
           config.setIdleTimeout(30000); // idle timeout
           dataSource = new HikariDataSource(config);
       }
   
       public static HikariDataSource getDataSource() {
           return dataSource;
       }
   }
   

3. Using DataSource in JasperReports: JasperReports-এ HikariCP DataSource ব্যবহার করে ডেটাবেসের সংযোগ স্থাপন করা হবে।

   import net.sf.jasperreports.engine.*;
   import net.sf.jasperreports.engine.data.JRResultSetDataSource;
   import java.sql.*;
   
   public class ReportGenerator {
       public static void generateReport() throws JRException {
           try {
               // Get a connection from the pool
               Connection connection = DatabaseConnectionPool.getDataSource().getConnection();
   
               // Create a JRResultSetDataSource (using the connection)
               Statement stmt = connection.createStatement();
               ResultSet rs = stmt.executeQuery("SELECT * FROM orders");
               JRResultSetDataSource resultSetDataSource = new JRResultSetDataSource(rs);
   
               // Compile and fill the report
               JasperReport jasperReport = JasperCompileManager.compileReport("report.jrxml");
               JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, null, resultSetDataSource);
   
               // Export report to PDF
               JasperExportManager.exportReportToPdfFile(jasperPrint, "report_output.pdf");
   
               // Close the connection
               connection.close();
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
   }
   

এখানে:

• HikariCP DataSource ব্যবহার করা হয়েছে যা JasperReports-এর জন্য ডেটাবেস সংযোগ পুলিং নিশ্চিত করছে।
• JDBC Connection থেকে ডেটা ফেচ করে JasperReport তৈরি করা হয়েছে এবং সেটি PDF আউটপুটে রেন্ডার করা হয়েছে।

2. Transaction Management in JasperReports

Transaction Management হল একটি টেকনিক যা ডেটাবেসের সঙ্গেই সম্পর্কিত ডেটা টানানো এবং সেই ডেটার ওপর বিভিন্ন কর্ম সম্পাদন করার জন্য ব্যবহৃত হয়। JasperReports-এ যখন আপনি JDBC থেকে ডেটা ফেচ করেন, তখন রিপোর্ট তৈরির সময় আপনি ডেটাবেসের ট্রানজেকশন ম্যানেজমেন্ট কনফিগার করে নিশ্চিত করতে পারেন যে সমস্ত ডেটা সঠিকভাবে সম্পাদিত হচ্ছে এবং একাধিক রিপোর্টে ডেটা পরিবর্তন হলে rollback বা commit কার্যকর করা হয়।

JasperReports সাধারণত JDBC connection ব্যবহার করে ডেটা সংগ্রহ করে, তাই আপনি Transaction Management ব্যবহার করে ডেটা আপডেট এবং রিপোর্টের মধ্যে consistency নিশ্চিত করতে পারেন।

Transaction Management Example Using JDBC in JasperReports

import java.sql.*;
import javax.sql.DataSource;

public class TransactionManagement {
    private static Connection connection;

    public static void startTransaction() throws SQLException {
        // Begin transaction
        connection = DatabaseConnectionPool.getDataSource().getConnection();
        connection.setAutoCommit(false); // Disable auto-commit for transaction
    }

    public static void commitTransaction() throws SQLException {
        connection.commit(); // Commit the transaction
    }

    public static void rollbackTransaction() throws SQLException {
        connection.rollback(); // Rollback the transaction in case of failure
    }

    public static void closeTransaction() throws SQLException {
        if (connection != null) {
            connection.close(); // Close connection after transaction
        }
    }
}

Using Transaction Management in JasperReports:

1. Start the transaction before fetching the data and generating the report.
2. Commit the transaction after the report is successfully generated.
3. If any error occurs, you can rollback the transaction to maintain consistency.

public class ReportWithTransaction {
    public static void generateReport() throws JRException {
        try {
            // Start transaction
            TransactionManagement.startTransaction();

            // Get data from the database (similar to the previous example)
            Statement stmt = connection.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT * FROM orders");
            JRResultSetDataSource resultSetDataSource = new JRResultSetDataSource(rs);

            // Compile and fill the report
            JasperReport jasperReport = JasperCompileManager.compileReport("report.jrxml");
            JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, null, resultSetDataSource);

            // Export report to PDF
            JasperExportManager.exportReportToPdfFile(jasperPrint, "report_output.pdf");

            // Commit transaction after successful report generation
            TransactionManagement.commitTransaction();

        } catch (SQLException e) {
            e.printStackTrace();
            try {
                // Rollback transaction in case of error
                TransactionManagement.rollbackTransaction();
            } catch (SQLException rollbackException) {
                rollbackException.printStackTrace();
            }
        } finally {
            try {
                // Close the transaction and connection
                TransactionManagement.closeTransaction();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

Benefits of Database Connection Pooling and Transaction Management in JasperReports

1. Performance Improvement:
   • Connection pooling নিশ্চিত করে যে একই ডেটাবেস সংযোগ বারবার তৈরি করা না হয়। এর ফলে সংযোগ তৈরির খরচ কমে যায় এবং রিপোর্ট দ্রুত তৈরি হয়।
2. Resource Efficiency:
   • সংযোগ পুলিং ডেটাবেস সংযোগের উপযুক্ত ব্যবস্থাপনা নিশ্চিত করে, ফলে অ্যাপ্লিকেশন সিস্টেমের resources (যেমন memory, CPU) আরও দক্ষভাবে ব্যবহৃত হয়।
3. Data Consistency:
   • Transaction management রিপোর্ট তৈরির সময় ডেটার consistency নিশ্চিত করে। যখন একাধিক রিপোর্টে ডেটা পরিবর্তন হয়, তখন rollback বা commit এর মাধ্যমে ডেটার সঠিকতা বজায় থাকে।
4. Error Handling:
   • যদি কোনো ত্রুটি ঘটে, transaction rollback নিশ্চিত করে যে ডেটাবেসের কোনো অপর্যাপ্ত পরিবর্তন বা ক্ষতি না হয়।

1. Database Connection Pooling JasperReports-এ JDBC সংযোগকে পুনঃব্যবহারযোগ্য করে তোলে এবং performance বৃদ্ধি করে।
2. Transaction Management ডেটা consistency এবং integrity বজায় রাখে, বিশেষ করে যখন একাধিক ডেটাবেস পরিবর্তন হয়।
3. HikariCP ব্যবহার করে connection pooling এবং transaction management প্রক্রিয়া দ্রুত এবং কার্যকরী করা সম্ভব, যা JasperReports-এ ডেটা সংগ্রহ এবং রিপোর্ট তৈরির কাজকে আরও দক্ষ করে তোলে।