69

最近我开始听说“POJO”（Plain Old Java Objects）。我用谷歌搜索了它，但仍然不太了解这个概念。谁能给我一个POJO的清晰描述？

考虑一个带有变量“id、name、address、salary”的类“Person”——我将如何为这个场景创建一个 POJO？下面的代码是 POJO 吗？

public class Person {
    //variables
    People people = new People();
    private int id;
    private String name;
    private String address;
    private int salary;


    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getAddress() {
        return address;
    }

    public int getSalary() {
        return salary;
    }

    public void setId() {
        this.id = id;
    }

    public void setName() {
        this.name = name;
    }

    public void setAddress() {
        this.address = address;
    }

    public void setSalary() {
        this.salary = salary;
    }
}
4

11 回答 11

83

POJO 只是一个简单的、旧的 Java Bean，去掉了限制。Java Bean 必须满足以下要求：

  1. 默认无参数构造函数
  2. 遵循 getFoo 的 Bean 约定（或布尔值的 isFoo）和名为 foo 的可变属性的 setFoo 方法；如果 foo 是不可变的，则不要使用 setFoo。
  3. 必须实现 java.io.Serializable

POJO 不强制要求任何这些。顾名思义：在JDK下编译的对象可以被认为是Plain Old Java Object。没有应用服务器，没有基类，不需要使用接口。

首字母缩略词 POJO 是对 EJB 2.0 的反应，它需要几个接口、扩展的基类和许多方法来做简单的事情。一些人，其中包括 Rod Johnson 和 Martin Fowler，反对复杂性并寻求一种无需编写 EJB 即可实现企业级解决方案的方法。

Martin Fowler 创造了一个新的缩写词。

Rod Johnson 写了“没有 EJB 的 J2EE”，写了 Spring，对 EJB 产生了足够的影响，所以 3.1 版看起来很像 Spring 和 Hibernate，并且从 VMWare 那里获得了一个甜蜜的 IPO。

这是一个您可以绕开的示例：

public class MyFirstPojo
{
    private String name;

    public static void main(String [] args)
    {
       for (String arg : args)
       {
          MyFirstPojo pojo = new MyFirstPojo(arg);  // Here's how you create a POJO
          System.out.println(pojo); 
       }
    }

    public MyFirstPojo(String name)
    {    
        this.name = name;
    }

    public String getName() { return this.name; } 

    public String toString() { return this.name; } 
}
于 2010-08-20T00:24:44.220 回答
29

POJO：- POJO 是一个 Java 对象，除了 Java 语言规范强制的限制之外，不受任何限制。

POJO的属性

  1. 所有属性都必须是公共的 setter 和 getter 方法
  2. 所有实例变量都应该是私有的
  3. 不应扩展预先指定的类。
  4. 不应实现预先指定的接口。
  5. 不应包含预先指定的注释。
  6. 它可能没有任何参数构造函数

POJO 示例

public class POJO {

    private String value;

    public String getValue() {
         return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}
于 2014-01-24T09:41:10.663 回答
5

POJO 是一个普通的旧 Java 对象。

从我链接到的维基百科文章：

在计算软件中，POJO 是 Plain Old Java Object 的首字母缩写。该名称用于强调给定对象是普通 Java 对象，而不是特殊对象，尤其不是Enterprise JavaBean

您的班级似乎已经是 POJO。

于 2010-08-20T00:06:35.567 回答
4

POJO 类充当用于设置和获取值的 bean。

public class Data
{


private int id;
    private String deptname;
    private String date;
    private String name;
    private String mdate;
    private String mname;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getDeptname() {
        return deptname;
    }

    public void setDeptname(String deptname) {
        this.deptname = deptname;
    }

    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getMdate() {
        return mdate;
    }

    public void setMdate(String mdate) {
        this.mdate = mdate;
    }

    public String getMname() {
        return mname;
    }

    public void setMname(String mname) {
        this.mname = mname;
    }
}
于 2013-06-11T09:52:06.670 回答
2

当您没有做任何事情来使您的类特别设计为与给定的框架、ORM 或其他需要特殊类的系统一起使用时，您就有了一个普通的旧 Java 对象或 POJO。

具有讽刺意味的是，创造这个词的原因之一是人们在明智的情况下会避开它们，有些人认为这是因为他们没有一个花哨的名字。具有讽刺意味的是，因为您的问题表明该方法有效。

将较旧的 POD“Plain Old Data”与不执行 C 结构无法执行的任何操作的 C++ 类进行比较（或多或少，不是析构函数或普通构造函数的非虚拟成员不会阻止它成为被认为是 POD），以及 .NET 中更新的（更直接可比的）POCO“普通旧 CLR 对象”。

于 2010-08-20T00:11:50.080 回答
2

根据马丁·福勒

这个术语是在 Rebecca Parsons、Josh MacKenzie 和我准备在 2000 年 9 月的一次会议上发表演讲时创造的。在演讲中，我们指出了将业务逻辑编码到常规 Java 对象而不是使用实体 Bean 的许多好处。我们想知道为什么人们如此反对在他们的系统中使用常规对象，并得出结论，这是因为简单的对象缺乏花哨的名称。所以我们给了他们一个，它很受欢迎。

通常，POJO 不受任何限制，任何 Java 对象都可以称为 POJO，但有一些方向。定义明确的 POJO 应遵循以下说明。

  1. POJO 中的每个变量都应该声明为私有的。
  2. 默认构造函数应该被公共可访问性覆盖。
  3. 每个变量都应该有其具有公共可访问性的 Setter-Getter 方法。
  4. 通常 POJO 应该覆盖 Object 的 equals()、hashCode() 和 toString() 方法（但这不是强制性的）。
  5. 覆盖用于排序的 Comparable 接口的 compare() 方法（首选但不是强制性的）。

并且根据 Java 语言规范，POJO 不必

  1. 扩展预先指定的类
  2. 实现预先指定的接口
  3. 包含预先指定的注释

然而，开发人员和框架描述 POJO 仍然需要使用预先指定的注解来实现诸如持久性、声明性事务管理等特性。所以想法是，如果在添加任何注解之前对象是 POJO，如果注解是删除，那么它仍然可以被认为是一个 POJO。

JavaBean 是一种特殊的 POJO，它是可序列化的，具有无参数构造函数，并允许使用遵循简单命名约定的 getter 和 setter 方法访问属性。

阅读更多关于普通旧 Java 对象 (POJO) 的解释。

于 2018-08-07T09:53:05.200 回答
1

主要有三个选项可以用于映射目的

  1. 连载
  2. XML 映射
  3. POJO 映射。（普通的旧 Java 对象）

在使用 pojo 类时，开发人员很容易与数据库进行映射。POJO 类是为数据库创建的，同时使用 getter 和 setter 方法创建值对象类，这些方法可以轻松保存内容。

因此，为了实现 java 与数据库之间的映射，实现了值对象和 POJO 类。

于 2014-05-27T11:53:09.013 回答
1 
import java.io.Serializable;

public class Course implements Serializable {

    protected int courseId;
    protected String courseName;
    protected String courseType;

    public Course() {
        courseName = new String();
        courseType = new String();
    }

    public Course(String courseName, String courseType) {
        this.courseName = courseName;
        this.courseType = courseType;
    }

    public Course(int courseId, String courseName, String courseType) {
        this.courseId = courseId;
        this.courseName = courseName;
        this.courseType = courseType;
    }

    public int getCourseId() {
        return courseId;
    }

    public void setCourseId(int courseId) {
        this.courseId = courseId;
    }

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public String getCourseType() {
        return courseType;
    }

    public void setCourseType(String courseType) {
        this.courseType = courseType;
    }

    @Override
    public int hashCode() {
        return courseId;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj != null || obj instanceof Course) {
            Course c = (Course) obj;
            if (courseId == c.courseId && courseName.equals(c.courseName)
                    && courseType.equals(c.courseType))
                return true;
        }
        return false;
    }

    @Override
    public String toString() {
        return "Course[" + courseId + "," + courseName + "," + courseType + "]";
    }
}
于 2015-11-30T17:04:39.953 回答
0
  1. 文件-设置-插件-浏览存储库
  2. 搜索 RoboPOJOGenerator 并安装，重启 Android studio
  3. 打开项目并右键单击从 JSON 生成 POJO 上的包选择
  4. 在对话框中粘贴 JSON 并根据您的要求选择选项
  5. 点击生成按钮
于 2020-05-05T08:02:08.203 回答
0 
public class UserInfo {
        String LoginId;
        String Password;
        String FirstName;
        String LastName;
        String Email;
        String Mobile;
        String Address;
        String DOB;

        public String getLoginId() {
            return LoginId;
        }

        public void setLoginId(String loginId) {
            LoginId = loginId;
        }

        public String getPassword() {
            return Password;
        }

        public void setPassword(String password) {
            Password = password;
        }

        public String getFirstName() {
            return FirstName;
        }

        public void setFirstName(String firstName) {
            FirstName = firstName;
        }

        public String getLastName() {
            return LastName;
        }

        public void setLastName(String lastName) {
            LastName = lastName;
        }

        public String getEmail() {
            return Email;
        }

        public void setEmail(String email) {
            Email = email;
        }

        public String getMobile() {
            return Mobile;
        }

        public void setMobile(String mobile) {
            Mobile = mobile;
        }

        public String getAddress() {
            return Address;
        }

        public void setAddress(String address) {
            Address = address;
        }

        public String getDOB() {
            return DOB;
        }

        public void setDOB(String DOB) {
            this.DOB = DOB;
        }
    }
于 2016-11-23T06:09:47.497 回答
0

如果一个类没有从框架或库中陷入困境，那么从该类创建的对象被识别为POJO。

让我们看一些例子：

class MyServlet extends HttpServlet{
    //....
}

MyServlet 类的唯一含义由 HttpServlet 类给出。因此，从 MyServlet 创建的对象不是POJO。

class MyClass implements Serializable{
    //...
}

Serializable 接口没有赋予类 MyClass 任何意义。因此，从 MyClass 创建的对象是POJO。

于 2021-12-13T05:11:41.193 回答