Data access object (DAO) ใน Java

DAOผมจะผ่านเอกสารและผมมาในระยะที่เรียกว่า ฉันพบว่ามันเป็น Data Access Object ใครช่วยอธิบายหน่อยได้ไหมว่ามันคืออะไร

ฉันรู้ว่ามันเป็นอินเทอร์เฟซสำหรับการเข้าถึงข้อมูลจากแหล่งข้อมูลประเภทต่าง ๆ ในช่วงกลางของการวิจัยเล็ก ๆ น้อย ๆ ของฉันฉันชนกับแนวคิดที่เรียกว่าแหล่งข้อมูลหรือแหล่งข้อมูลวัตถุและสิ่งต่าง ๆ ทำให้สับสนในใจ

ฉันต้องการทราบว่า a DAOคือโปรแกรมในแง่ของที่ใช้ มันถูกใช้อย่างไร? ลิงก์ใด ๆ ที่เชื่อมโยงไปยังหน้าเว็บที่อธิบายแนวคิดนี้จากสิ่งพื้นฐานมาก ๆ ก็ชื่นชมเช่นกัน

Data Access Object นั้นเป็นวัตถุหรืออินเตอร์เฟสที่ให้การเข้าถึงฐานข้อมูลพื้นฐานหรือที่เก็บข้อมูลการมีอยู่อื่น

คำจำกัดความนั้นมาจาก: http://en.wikipedia.org/wiki/Data_access_object

ตรวจสอบแผนภาพลำดับที่นี่: http://www.oracle.com/technetwork/java/dataaccessobject-138824.html

ตัวอย่างง่ายๆอาจช่วยให้คุณเข้าใจแนวคิด:

สมมติว่าเรามีหน่วยงานที่เป็นตัวแทนของพนักงาน:

public class Employee {

    private int id;
    private String name;


    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

เอนทิตีของพนักงานจะยังคงอยู่ในEmployeeตารางที่สอดคล้องกันในฐานข้อมูล อินเตอร์เฟส DAO แบบง่ายเพื่อจัดการการดำเนินการฐานข้อมูลที่ต้องการเพื่อจัดการกับเอนทิตีของพนักงานจะเป็นดังนี้:

interface EmployeeDAO {

    List<Employee> findAll();
    List<Employee> findById();
    List<Employee> findByName();
    boolean insertEmployee(Employee employee);
    boolean updateEmployee(Employee employee);
    boolean deleteEmployee(Employee employee);

}

ต่อไปเราจะต้องจัดเตรียมการติดตั้งที่เป็นรูปธรรมสำหรับอินเตอร์เฟสนั้นเพื่อจัดการกับเซิร์ฟเวอร์ SQL และอีกส่วนเพื่อจัดการกับไฟล์แบบแฟลต ฯลฯ

วัตถุเข้าถึงข้อมูลอะไร (DAO) -

มันเป็นวัตถุ / อินเตอร์เฟสซึ่งใช้ในการเข้าถึงข้อมูลจากฐานข้อมูลของการจัดเก็บข้อมูล

ทำไมเราใช้ DAO:

มันเป็นนามธรรมการดึงข้อมูลจากแหล่งข้อมูลเช่นฐานข้อมูล แนวคิดคือ"แยกส่วนติดต่อลูกค้าของทรัพยากรข้อมูลออกจากกลไกการเข้าถึงข้อมูล"

ปัญหาในการเข้าถึงข้อมูลโดยตรงคือแหล่งที่มาของข้อมูลสามารถเปลี่ยนแปลงได้ ตัวอย่างเช่นพิจารณาว่าแอปพลิเคชันของคุณถูกปรับใช้ในสภาพแวดล้อมที่เข้าถึงฐานข้อมูล Oracle จากนั้นจะปรับใช้กับสภาพแวดล้อมที่ใช้ Microsoft SQL Server ในภายหลัง หากแอปพลิเคชันของคุณใช้กระบวนงานที่เก็บไว้และรหัสเฉพาะฐานข้อมูล (เช่นสร้างลำดับหมายเลข) คุณจะจัดการกับแอปพลิเคชันของคุณได้อย่างไร คุณมีสองทางเลือก:

• เขียนแอปพลิเคชันของคุณใหม่เพื่อใช้ SQL Server แทน Oracle (หรือเพิ่มรหัสเงื่อนไขเพื่อจัดการความแตกต่าง) หรือ
• สร้างเลเยอร์ขึ้นมาระหว่างตรรกะแอปพลิเคชันของคุณและการเข้าถึงข้อมูล

มันในทุกรูปแบบที่เรียกว่าDAOมันประกอบด้วยดังต่อไปนี้:

• Data Access Object Interface - อินเตอร์เฟสนี้กำหนดการดำเนินงานมาตรฐานที่จะดำเนินการกับวัตถุโมเดล
• คลาสข้อมูลการเข้าถึงออบเจกต์คอนกรีต - คลาสนี้ใช้ส่วนติดต่อด้านบน คลาสนี้มีหน้าที่รับข้อมูลจากแหล่งข้อมูลซึ่งอาจเป็นฐานข้อมูล / xml หรือกลไกการจัดเก็บอื่น ๆ
• Model Object หรือ Value Object - วัตถุนี้ง่าย POJO ที่มีวิธีการ get / setเพื่อเก็บข้อมูลที่ดึงมาโดยใช้คลาส DAO

โปรดตรวจสอบตัวอย่างนี้สิ่งนี้จะชัดเจนยิ่งขึ้น

ตัวอย่าง
ฉันสมมติว่าสิ่งนี้ต้องทำให้คุณเข้าใจ DAO ได้มากขึ้น

DAO (Data Access Object) เป็นรูปแบบการออกแบบที่ใช้กันอย่างแพร่หลายในแอพพลิเคชั่นขององค์กร มันเป็นโมดูลที่ใช้ในการเข้าถึงข้อมูลจากทุกแหล่ง (DBMS, XML และอื่น ๆ ) ฉันขอแนะนำให้คุณอ่านตัวอย่างเช่นนี้:

ตัวอย่าง DAO

โปรดทราบว่ามีวิธีการที่แตกต่างกันในการนำรูปแบบ DAOดั้งเดิมมาใช้และมีกรอบงานมากมายที่สามารถทำให้งานของคุณง่ายขึ้น ตัวอย่างเช่นเฟรมเวิร์ก ORM (Object Relational Mapping) เช่น iBatis หรือ Hibernate ใช้เพื่อแม็พผลลัพธ์ของเคียวรี SQL กับอ็อบเจ็กต์ java

หวังว่าจะช่วยลาก่อน!

รูปแบบวัตถุการเข้าถึงข้อมูลหรือรูปแบบ DAO ใช้เพื่อแยกข้อมูลระดับต่ำที่เข้าถึง API หรือการดำเนินงานจากบริการทางธุรกิจระดับสูง ต่อไปนี้เป็นผู้เข้าร่วมในรูปแบบวัตถุการเข้าถึงข้อมูล

Data Access Object Interface - อินเตอร์เฟสนี้กำหนดการดำเนินงานมาตรฐานที่จะดำเนินการกับวัตถุโมเดล

คลาสข้อมูลการเข้าถึงออบเจกต์คอนกรีต - คลาสนี้ใช้ส่วนติดต่อด้านบน คลาสนี้มีหน้าที่รับข้อมูลจากแหล่งข้อมูลซึ่งอาจเป็นฐานข้อมูล / xml หรือกลไกการจัดเก็บอื่น ๆ

Model Object หรือ Value Object - วัตถุนี้ง่าย POJO ที่มีวิธีการ get / set เพื่อเก็บข้อมูลที่ดึงมาโดยใช้คลาส DAO

โค้ดตัวอย่างที่นี่ ..

ฉันจะเป็นคนทั่วไปและไม่เฉพาะเจาะจงกับ Java เนื่องจาก DAO และ ORM ถูกใช้ในทุกภาษา

ในการทำความเข้าใจ DAO คุณต้องเข้าใจ ORM ก่อน (การทำแผนที่วัตถุสัมพันธ์) ซึ่งหมายความว่าหากคุณมีตารางชื่อ "บุคคล" ที่มีคอลัมน์ "ชื่อ" และ "อายุ" คุณจะต้องสร้างแม่แบบวัตถุสำหรับตารางนั้น:

type Person {
name
age
}

ตอนนี้ด้วยความช่วยเหลือของ DAO แทนที่จะเขียนข้อความค้นหาเฉพาะเพื่อดึงข้อมูลทุกคนสำหรับประเภทของฐานข้อมูลที่คุณใช้ (ซึ่งอาจเป็นข้อผิดพลาดได้ง่าย) แทนที่จะทำดังนี้:

list persons = DAO.getPersons();
...
person = DAO.getPersonWithName("John");
age = person.age;

คุณไม่ได้เขียน DAO abstraction ด้วยตัวเอง แต่โดยปกติจะเป็นส่วนหนึ่งของโปรเจคโอเพนซอร์สบางอย่าง

ตอนนี้กับคำถามหลักที่นี่ " .. มันถูกใช้ทุกที่ .. " โดยปกติถ้าคุณเขียนธุรกิจที่ซับซ้อนและรหัสเฉพาะโดเมนชีวิตของคุณจะยากมากหากไม่มี DAO แน่นอนคุณไม่จำเป็นต้องใช้ ORM และ DAO ที่ให้มาแทนคุณสามารถเขียนสิ่งที่เป็นนามธรรมและคำสั่งพื้นฐานได้ ฉันได้ทำสิ่งนั้นในอดีตและรู้สึกเสียใจในภายหลัง

ผมคิดว่าตัวอย่างที่ดีที่สุด (พร้อมกับคำอธิบาย) คุณสามารถค้นหาบนเว็บไซต์พยากรณ์: ที่นี่ อีก tuturial ดีอาจจะพบได้ที่นี่

อย่าสับสนกับคำอธิบายมากเกินไป DAO: จากชื่อตัวเองมันหมายถึงการเข้าถึงข้อมูลโดยใช้วัตถุ DAO ถูกแยกออกจากตรรกะทางธุรกิจอื่น ๆ

Data Access Object จัดการการเชื่อมต่อกับแหล่งข้อมูลเพื่อรับและจัดเก็บข้อมูลบทคัดย่อการดำเนินการเข้าถึงข้อมูลพื้นฐานสำหรับ Business Object เพื่อเปิดใช้งานการเข้าถึงแหล่งข้อมูลอย่างโปร่งใส แหล่งข้อมูลอาจเป็นฐานข้อมูลใด ๆ เช่น RDBMS, ที่เก็บ XML หรือระบบไฟล์แฟลตเป็นต้น

ฤดูใบไม้ผลิ JPA DAO

ตัวอย่างเช่นเรามีกลุ่มเอนทิตี

สำหรับเอนทิตีนี้เราสร้างที่เก็บ GroupRepository

public interface GroupRepository extends JpaRepository<Group, Long> {   
}

จากนั้นเราต้องสร้างชั้นบริการที่เราจะใช้พื้นที่เก็บข้อมูลนี้

public interface Service<T, ID> {

    T save(T entity);

    void deleteById(ID id);

    List<T> findAll();

    T getOne(ID id);

    T editEntity(T entity);

    Optional<T> findById(ID id);
}

public abstract class AbstractService<T, ID, R extends JpaRepository<T, ID>> implements Service<T, ID> {

    private final R repository;

    protected AbstractService(R repository) {
        this.repository = repository;
    }

    @Override
    public T save(T entity) {
        return repository.save(entity);
    }

    @Override
    public void deleteById(ID id) {
        repository.deleteById(id);
    }

    @Override
    public List<T> findAll() {
        return repository.findAll();
    }

    @Override
    public T getOne(ID id) {
        return repository.getOne(id);
    }

    @Override
    public Optional<T> findById(ID id) {
        return repository.findById(id);
    }

    @Override
    public T editEntity(T entity) {
        return repository.saveAndFlush(entity);
    }
}

@org.springframework.stereotype.Service
public class GroupServiceImpl extends AbstractService<Group, Long, GroupRepository> {

    private final GroupRepository groupRepository;

    @Autowired
    protected GroupServiceImpl(GroupRepository repository) {
        super(repository);
        this.groupRepository = repository;
    }
}

และในคอนโทรลเลอร์เราใช้บริการนี้

@RestController
@RequestMapping("/api")
class GroupController {

    private final Logger log = LoggerFactory.getLogger(GroupController.class);

    private final GroupServiceImpl groupService;

    @Autowired
    public GroupController(GroupServiceImpl groupService) {
        this.groupService = groupService;
    }

    @GetMapping("/groups")
    Collection<Group> groups() {
        return groupService.findAll();
    }

    @GetMapping("/group/{id}")
    ResponseEntity<?> getGroup(@PathVariable Long id) {
        Optional<Group> group = groupService.findById(id);
        return group.map(response -> ResponseEntity.ok().body(response))
                .orElse(new ResponseEntity<>(HttpStatus.NOT_FOUND));
    }

    @PostMapping("/group")
    ResponseEntity<Group> createGroup(@Valid @RequestBody Group group) throws URISyntaxException {
        log.info("Request to create group: {}", group);
        Group result = groupService.save(group);
        return ResponseEntity.created(new URI("/api/group/" + result.getId()))
                .body(result);
    }

    @PutMapping("/group")
    ResponseEntity<Group> updateGroup(@Valid @RequestBody Group group) {
        log.info("Request to update group: {}", group);
        Group result = groupService.save(group);
        return ResponseEntity.ok().body(result);
    }

    @DeleteMapping("/group/{id}")
    public ResponseEntity<?> deleteGroup(@PathVariable Long id) {
        log.info("Request to delete group: {}", id);
        groupService.deleteById(id);
        return ResponseEntity.ok().build();
    }    
}

DAO เป็นการกระทำที่เหมือน "Persistence Manager" ในสถาปัตยกรรม 3 ชั้นรวมถึง DAO ยังออกแบบรูปแบบตามที่คุณสามารถอ่านหนังสือ "Gang of Four" ชั้นบริการแอปพลิเคชันของคุณเพียงแค่ต้องเรียกวิธีการของคลาส DAO โดยไม่ต้องทราบรายละเอียดที่ซ่อนอยู่และภายในของวิธีการ DAO

Dao clases ใช้เพื่อนำ jdbc logic & Dao (Data Access Object) มาใช้ซ้ำเป็นรูปแบบการออกแบบ dao เป็นคลาส java อย่างง่ายซึ่งมีตรรกะ JDBC

Data Access Layer ได้พิสูจน์แล้วว่าดีในการแยกชั้นตรรกะทางธุรกิจและชั้นถาวร รูปแบบการออกแบบ DAO สมบูรณ์ซ่อนการใช้งานการเข้าถึงข้อมูลจากลูกค้า

Java Data Access Object (Java DAO) เป็นองค์ประกอบสำคัญในแอปพลิเคชันทางธุรกิจ แอปพลิเคชันทางธุรกิจมักต้องการการเข้าถึงข้อมูลจากฐานข้อมูลเชิงสัมพันธ์หรือเชิงวัตถุและแพลตฟอร์ม Java นำเสนอเทคนิคมากมายสำหรับการเข้าถึงข้อมูลนี้ เทคนิคที่เก่าแก่ที่สุดและเป็นผู้ใหญ่ที่สุดคือการใช้ Java Database Connectivity (JDBC) API ซึ่งให้ความสามารถในการดำเนินการสืบค้น SQL กับฐานข้อมูลจากนั้นดึงผลลัพธ์ผลลัพธ์ทีละหนึ่งคอลัมน์

Pojo ยังพิจารณาเป็น Model class ใน Java ซึ่งเราสามารถสร้าง getter และ setter สำหรับตัวแปรเฉพาะที่กำหนดไว้ใน private โปรดจำไว้ว่าตัวแปรทั้งหมดได้รับการประกาศที่นี่ด้วยตัวดัดแปลงส่วนตัว