精华内容
下载资源
问答
  • POJO类

    千次阅读 2018-10-14 13:49:54
    java对象 POJO和JavaBean的区别   "Plain Ordinary Java Object",简单普通的java对象。主要用来指代那些没有遵循特定的java对象...没有从任何继承、也没有实现任何接口,更没有被其它框架侵入的jav...

    java对象 POJO和JavaBean的区别

     

    "Plain Ordinary Java Object",简单普通的java对象。主要用来指代那些没有遵循特定的java对象模型约定或者框架的对象

    POJO的内在含义是指那些:
    有一些private的参数作为对象的属性,然后针对每一个参数定义get和set方法访问的接口。
    没有从任何类继承、也没有实现任何接口,更没有被其它框架侵入的java对象。

    public class BasicInfoVo {
    
    
    private String orderId;
    
    
    private Integer uid;
    
    
    
    public String getOrderId() {
    
    return orderId;
    
    }
    
    
    public void setOrderId(String orderId) {
    
    this.orderId = orderId;
    
    }
    
    
    public Integer getUid() {
    
    return uid;
    
    }
    
    
    public void setUid(Integer uid) {
    
    this.uid = uid;
    
    }}
    
     

     

    JavaBean

    JavaBean 是一种JAVA语言写成的可重用组件。JavaBean符合一定规范编写的Java类,不是一种技术,而是一种规范。大家针对这种规范,总结了很多开发技巧、工具函数。符合这种规范的类,可以被其它的程序员或者框架使用。它的方法命名,构造及行为必须符合特定的约定:

    1. 所有属性为private。

    2. 这个类必须有一个公共的缺省构造函数。即是提供无参数的构造器。

    3. 这个类的属性使用getter和setter来访问,其他方法遵从标准命名规范。

    4. 这个类应是可序列化的。实现serializable接口。

    因为这些要求主要是靠约定而不是靠实现接口,所以许多开发者把JavaBean看作遵从特定命名约定的POJO。

    1. public class UserInfo implements java.io.Serializable{
      
      
      //实现serializable接口。
      
      private static final long serialVersionUID = 1L;
      
      
      private String name;
      
      private int age;
      
      
      //无参构造器
      
      public UserInfo() {
      
      
      }
      
      
      public String getName() {
      
      return name;
      
      }
      
      
      public void setName(String name) {
      
      this.name = name;
      
      }
      
      
      public int getAge() {
      
      return age;
      
      }
      
      
      public void setAge(int age) {
      
      this.age = age;
      
      }

       

    2. //javabean当中可以有其它的方法

    3. public void userInfoPrint(){

    4. System.out.println("");

    5. } }

    两者有什么区别

    1. POJO其实是比javabean更纯净的简单类或接口。POJO严格地遵守简单对象的概念,而一些JavaBean中往往会封装一些简单逻辑。

    2. POJO主要用于数据的临时传递,它只能装载数据, 作为数据存储的载体,而不具有业务逻辑处理的能力。

    3. Javabean虽然数据的获取与POJO一样,但是javabean当中可以有其它的方法。

    参考链接:https://blog.csdn.net/kobexiaol/article/details/78195856

    此文用于个人学习

    以下内容为转载,出处已未知:

     

    POJO(Plain Old Java Object)这种叫法是Martin FowlerRebecca ParsonsJosh MacKenzie2000年的一次演讲的时候提出来的。
         现在网上对于POJO的解释很多,但是很多都是有错误的或者不够准确。对此我一开始也是存在误区的,我原来是这样理解的:
            POJO是这样的一种“纯粹的”JavaBean,在它里面除了JavaBean规范的方法和属性没有别的东西,即private属性以及对这个属性方法的publicgetset方法。我们会发现这样的JavaBean很“单纯”,它只能装载数据,作为数据存储的载体,而不具有业务逻辑处理的能力。
        所以下面的代码被认为是POJO了。

    package com.tongking.spring; 

    public class DbHello implements Hello {

           private DictionaryDAO dao;

           public void setDao(DictionaryDAO dao) {

                  this.dao = dao;

           }

    }

            其实,这样的认为是错误的,我仔细阅读了《POJOs in Action》这本书的有关部分和
    POJO的最原始的出处http://martinfowler.com/bliki/POJO.html,
            The term was coined while Rebecca Parsons, Josh MacKenzie and I were preparing for a talk at a conference in September 2000. In the talk we were pointing out the many benefits of encoding business logic into regular java objects rather than using Entity Beans. We wondered why people were so against using regular objects in their systems and concluded that it was because simple objects lacked a fancy name. So we gave them one, and it''s caught on very nicely.

    基本的意思是我们要给具有业务逻辑处理的规则的Java对象(regular java objects)起了一个名字——POJO,这些Java对象不是EntityBeans(EJB的一种)。

            我又在http://www.webopedia.com/TERM/P/POJO.htm查到解释如下:

    POJO, or Plain Old Java Object, is a normal Java object class (that is, not aJavaBean, EntityBean etc.)  and does not serve any other special role nor does it implement any special interfaces of any of the Java frameworks. This term was coined by Martin Fowler, Rebbecca Parsons and Josh MacKenzie who believed that by creating the acronym POJO, such objects would have a "fancy name", thereby convincing people that they were worthy of use.
            基本意思是说POJO一个正规的Java对象(不是JavaBean,EntityBean等),也不担当任何的特殊的角色,也不实现任何Java框架指定的接口。
            我觉得上面的解释很准确,POJO应该不是我们开始认为的JavaBean,当然更不是EJB,它不应该依赖于框架即继承或实现某些框架类或接口。例如:Struts1中的Action和ActionForm当然不属于POJO了,而在Struts2中的Action由于可以不继承任何的接口,所以在这种情况下Action是POJO,但是Struts2中的Action也可以继承ActionSupport类就不再属于POJO了。POJO里面是可以包含业务逻辑处理和持久化逻辑,也可以包含类似与JavaBean属性和对属性访问的set和get方法的。
         
      最后,我们总结一下给一个定义把,POJO是一个简单的、正规Java对象,它包含业务逻辑处理或持久化逻辑等,但不是JavaBean、EntityBean等,不具有任何特殊角色和不继承或不实现任何其它Java框架的类或接口。

    参考:https://blog.csdn.net/huiguixian/article/details/6125877

    展开全文
  • pojo类继承pojo类 在Java中,您可以轻松地在Plain Old Java Object(POJO)类中实现一些业务逻辑,并且可以在高级服务器或框架中轻松运行它们。 有许多服务器/框架,例如JBossAS,Spring或Camel等,它们使您可以...

    pojo类继承pojo类

    在Java中,您可以轻松地在Plain Old Java Object(POJO)类中实现一些业务逻辑,并且可以在高级服务器或框架中轻松运行它们。 有许多服务器/框架,例如JBossAS,Spring或Camel等,它们使您可以部署POJO甚至不对其API进行硬编码。 显然,如果愿意耦合到它们的API细节,您将获得高级功能,但是即使您这样做,也可以通过将自己的POJO和他们的API封装在包装器中来使这些特性降至最低。 通过编写和设计尽可能简单的POJO自己的应用程序,您将拥有最灵活的方式来选择框架或服务器来部署和运行您的应用程序。 在这些环境中编写业务逻辑的一种有效方法是使用服务组件。 在本文中,我将分享在编写Services方面学到的一些知识。

    什么是服务?

    如今,“ 服务 ”一词已被过度使用,对不同的人可能意味着很多事情。 当我说Service时 ,我的定义是一个具有最小生命周期(例如initstartstopdestroy )的软件组件。 在编写的每个服务中,您可能不需要生命周期的所有这些阶段,但是您可以简单地忽略那些不适用的服务。 在编写旨在长期运行的大型应用程序(例如服务器组件)时,定义这些生命周期并确保按正确的顺序执行它们是至关重要的!

    我将带领您完成我准备的Java演示项目。 这是非常基础的,应该独立运行。 它具有的唯一依赖性是SLF4J记录器。 如果您不知道如何使用记录器,则只需将它们替换为System.out.println 但是,我强烈建议您学习在应用程序开发期间如何有效使用记录器。 另外,如果您想尝试与Spring相关的演示,那么显然您也将需要其jar。

    编写基本的POJO服务

    您可以在界面中如下所示快速定义具有生命周期的服务合同。

    package servicedemo;
    
    public interface Service {
        void init();
        void start();
        void stop();
        void destroy();
        boolean isInited();
        boolean isStarted();
    }

    开发人员可以自由地在Service实现中做他们想做的事情,但是您可能想给他们一个适配器类,这样他们就不必在每个Service上重写相同的基本逻辑。 我将提供这样的抽象服务:

    package servicedemo;
    
    import java.util.concurrent.atomic.*;
    import org.slf4j.*;
    public abstract class AbstractService implements Service {
        protected Logger logger = LoggerFactory.getLogger(getClass());
        protected AtomicBoolean started = new AtomicBoolean(false);
        protected AtomicBoolean inited = new AtomicBoolean(false);
    
        public void init() {
            if (!inited.get()) {
                initService();
                inited.set(true);
                logger.debug('{} initialized.', this);
            }
        }
    
        public void start() {
            // Init service if it has not done so.
            if (!inited.get()) {
                init();
            }
            // Start service now.
            if (!started.get()) {
                startService();
                started.set(true);
                logger.debug('{} started.', this);
            }
        }
    
        public void stop() {
            if (started.get()) {
                stopService();
                started.set(false);
                logger.debug('{} stopped.', this);
            }
        }
    
        public void destroy() {
            // Stop service if it is still running.
            if (started.get()) {
                stop();
            }
            // Destroy service now.
            if (inited.get()) {
                destroyService();
                inited.set(false);
                logger.debug('{} destroyed.', this);
            }
        }
    
        public boolean isStarted() {
            return started.get();
        }
    
        public boolean isInited() {
            return inited.get();
        }
    
        @Override
        public String toString() {
                return getClass().getSimpleName() + '[id=' + System.identityHashCode(this) + ']';
        }
    
        protected void initService() {
        }
    
        protected void startService() {
        }
    
        protected void stopService() {
        }
    
        protected void destroyService() {
        }
    }

    该抽象类提供大多数服务需求的基础。 它有一个记录器,并指出要跟踪的生命周期。 然后,它委托新的生命周期方法集,以便子类可以选择重写。 请注意, start()方法正在检查是否自动调用init() destroy()方法和stop()方法中也是如此。 如果我们要在只有两个阶段生命周期调用的容器中使用它,则这一点很重要。 在这种情况下,我们可以简单地调用start()destroy()来匹配我们服务的生命周期。

    一些框架可能会再进一步,对于生命周期,如每个阶段创建独立的接口InitableServiceStartableService等,但我认为这将是太多了在一个典型的应用。 在大多数情况下,您想要简单的东西,所以我只喜欢一个界面。 用户可以选择忽略不需要的方法,或仅使用适配器类。

    在结束本节之前,我将提供一个愚蠢的Hello world服务,以后可以在我们的演示中使用它。

    package servicedemo;
    
    public class HelloService extends AbstractService {
        public void initService() {
            logger.info(this + ' inited.');
        }
        public void startService() {
            logger.info(this + ' started.');
        }
        public void stopService() {
            logger.info(this + ' stopped.');
        }
        public void destroyService() {
            logger.info(this + ' destroyed.');
        }
    }


    使用容器管理多个POJO服务

    现在我们已经定义了服务定义的基础,您的开发团队可能会开始编写业务逻辑代码! 不久之后,您将拥有自己的服务库以供重新使用。 为了能够有效地对这些服务进行分组和控制,我们还希望提供一个容器来管理它们。 这个想法是,我们通常希望以一个容器作为更高级别的组来控制和管理多个服务。 这是一个入门的简单实现:

    package servicedemo;
    
    import java.util.*;
    public class ServiceContainer extends AbstractService {
        private List<Service> services = new ArrayList<Service>();
    
        public void setServices(List<Service> services) {
            this.services = services;
        }
        public void addService(Service service) {
            this.services.add(service);
        }
    
        public void initService() {
            logger.debug('Initializing ' + this + ' with ' + services.size() + ' services.');
            for (Service service : services) {
                logger.debug('Initializing ' + service);
                service.init();
            }
            logger.info(this + ' inited.');
        }
        public void startService() {
                logger.debug('Starting ' + this + ' with ' + services.size() + ' services.');
                for (Service service : services) {
                    logger.debug('Starting ' + service);
                    service.start();
                }
                logger.info(this + ' started.');
        }
        public void stopService() {
                int size = services.size();
                logger.debug('Stopping ' + this + ' with ' + size + ' services in reverse order.');
                for (int i = size - 1; i >= 0; i--) {
                    Service service = services.get(i);
                    logger.debug('Stopping ' + service);
                    service.stop();
                }
                logger.info(this + ' stopped.');
        }
        public void destroyService() {
                int size = services.size();
                logger.debug('Destroying ' + this + ' with ' + size + ' services in reverse order.');
                for (int i = size - 1; i >= 0; i--) {
                    Service service = services.get(i);
                    logger.debug('Destroying ' + service);
                    service.destroy();
                }
                logger.info(this + ' destroyed.');
        }
    }

    从上面的代码中,您会注意到一些重要的事情:

    1. 我们扩展了AbstractService,因此容器本身就是服务。
    2. 在进入下一个服务之前,我们将调用所有服务的生命周期。 除非启动所有其他服务,否则不会启动任何服务。
    3. 对于大多数一般用例,我们应该以相反的顺序停止和销毁服务。

    上面的容器实现很简单,并且以同步方式运行。 这意味着,您启动容器,然后所有服务将按照您添加它们的顺序启动。 停止应该相同,但顺序相反。

    我也希望您能够看到还有足够的空间来改进此容器。 例如,您可以添加线程池以异步方式控制服务的执行。

    运行POJO服务 通过简单的运行程序运行服务。

    以最简单的形式,我们可以自己运行POJO服务,而无需任何高级服务器或框架。 Java程序是从静态main方法开始的,因此我们肯定可以在其中调用initstart我们的服务。 但是,当用户关闭程序时(通常通过按CTRL+C ),我们还需要解决stopdestroy生命周期的问题。为此,Java具有java.lang.Runtime#addShutdownHook()功能。 您可以创建一个简单的独立服务器来引导服务,如下所示:

    package servicedemo;
    
    import org.slf4j.*;
    public class ServiceRunner {
        private static Logger logger = LoggerFactory.getLogger(ServiceRunner.class);
    
        public static void main(String[] args) {
            ServiceRunner main = new ServiceRunner();
            main.run(args);
        }
    
        public void run(String[] args) {
            if (args.length < 1)
                throw new RuntimeException('Missing service class name as argument.');
    
            String serviceClassName = args[0];
            try {
                logger.debug('Creating ' + serviceClassName);
                Class<?> serviceClass = Class.forName(serviceClassName);
                if (!Service.class.isAssignableFrom(serviceClass)) {
                    throw new RuntimeException('Service class ' + serviceClassName + ' did not implements ' + Service.class.getName());
                }
                Object serviceObject = serviceClass.newInstance();
                Service service = (Service)serviceObject;
    
                registerShutdownHook(service);
    
                logger.debug('Starting service ' + service);
                service.init();
                service.start();
                logger.info(service + ' started.');
    
                synchronized(this) {
                    this.wait();
                }
            } catch (Exception e) {
                throw new RuntimeException('Failed to create and run ' + serviceClassName, e);
            }
        }
    
        private void registerShutdownHook(final Service service) {
            Runtime.getRuntime().addShutdownHook(new Thread() {
                public void run() {
                    logger.debug('Stopping service ' + service);
                    service.stop();
                    service.destroy();
                    logger.info(service + ' stopped.');
                }
            });
        }
    }

    使用优于运行程序,您应该可以使用以下命令运行它:

    $ java demo.ServiceRunner servicedemo.HelloService

    仔细查看,您会发现您可以使用上述运行器有很多选择来运行多个服务。 让我突出几个:

    1. 直接改善上述运行器,并为每个新服务类名称(而不只是第一个元素)使用所有args
    2. 或编写一个MultiLoaderService来加载所需的多个服务。 您可以使用“系统属性”控制参数传递。

    您能想到其他改善这位跑步者的方法吗?

    使用Spring运行服务

    Spring框架是一个IoC容器,众所周知,它易于使用POJO,而Spring可让您将应用程序连接在一起。 这将非常适合在我们的POJO服务中使用。 但是,由于Spring具备了所有功能,因此错过了易于使用的现成的主程序来引导spring config xml上下文文件。 但是就目前为止构建的内容而言,这实际上是一件容易的事。 让我们编写一个POJO 服务来引导一个Spring上下文文件。

    package servicedemo;
    
    import org.springframework.context.ConfigurableApplicationContext;
    import org.springframework.context.support.FileSystemXmlApplicationContext;
    
    public class SpringService extends AbstractService {
        private ConfigurableApplicationContext springContext;
    
        public void startService() {
            String springConfig = System.getProperty('springContext', 'spring.xml);
            springContext = new FileSystemXmlApplicationContext(springConfig);
            logger.info(this + ' started.');
        }
        public void stopService() {
            springContext.close();
            logger.info(this + ' stopped.');
        }
    }

    使用该简单的SpringService您可以运行和加载任何spring xml文件。 例如,尝试以下操作:

    $ java -DspringContext=config/service-demo-spring.xml demo.ServiceRunner servicedemo.SpringService

    config/service-demo-spring.xml文件中,您可以轻松创建我们的容器,该容器在Spring Bean中承载一个或多个服务。

    <beans xmlns='http://www.springframework.org/schema/beans'
         xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
         xsi:schemaLocation='http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd'>
    
        <bean id='helloService' class='servicedemo.HelloService'>
        </bean>
    
        <bean id='serviceContainer' class='servicedemo.ServiceContainer' init-method='start' destroy-method='destroy'>
            <property name='services'>
                <list>
                    <ref bean='helloService'/>
                </list>
            </property>
        </bean>
    
    </beans>

    注意,我只需要在serviceContainer bean上设置一次init-methoddestroy-method 然后,您可以根据需要添加一个或多个其他服务,例如helloService 关闭Spring上下文时,它们将全部启动,管理,然后关闭。

    请注意,Spring上下文容器没有明确地具有与我们的服务相同的生命周期。 Spring上下文将自动实例化您的所有依赖项Bean,然后调用所有设置了init-method Bean。 所有这些操作都在FileSystemXmlApplicationContext的构造函数中完成。 用户未调用任何显式的init方法。 但是最后,在服务停止期间,Spring提供了container#close()来清理内容。 同样,它们不区分stop destroy 因此,我们必须合并我们的initstart进入Spring的init状态,然后合并stopdestroy进入Spring的close状态。 回想一下我们的AbstractService#destory会自动调用stop如果尚未执行的话)。 因此,为了有效地使用Spring,这是我们需要了解的技巧。

    使用JEE应用服务器运行服务

    在公司环境中,我们通常没有自由运行独立程序所需的内容。 相反,它们通常已经具有一些基础设施和更严格的标准技术堆栈,例如使用JEE应用程序服务器。 在这种情况下,运行POJO服务最可移植的是war Web应用程序。 在Servlet Web应用程序中,您可以编写一个实现javax.servlet.ServletContextListener的类,这将通过contextInitializedcontextDestroyed为您提供生命周期挂钩。 在其中,您可以实例化ServiceContainer对象,并相应地调用startdestroy方法。

    您可以浏览以下示例:

    package servicedemo;
    import java.util.*;
    import javax.servlet.*;
    public class ServiceContainerListener implements ServletContextListener {
        private static Logger logger = LoggerFactory.getLogger(ServiceContainerListener.class);
        private ServiceContainer serviceContainer;
    
        public void contextInitialized(ServletContextEvent sce) {
            serviceContainer = new ServiceContainer();
            List<Service> services = createServices();
            serviceContainer.setServices(services);
            serviceContainer.start();
            logger.info(serviceContainer + ' started in web application.');
        }
    
        public void contextDestroyed(ServletContextEvent sce) {
            serviceContainer.destroy();
            logger.info(serviceContainer + ' destroyed in web application.');
        }
    
        private List<Service> createServices() {
            List<Service> result = new ArrayList<Service>();
            // populate services here.
            return result;
        }
    }

    您可以像上面这样在WEB-INF/web.xml配置:

    <listener>
            <listener-class>servicedemo.ServiceContainerListener</listener-class>
        </listener>
    
    </web-app>

    该演示提供了一个占位符,您必须在代码中添加服务。 但是您可以使用web.xml作为上下文参数轻松地将其配置为可配置的。

    如果要在Servlet容器中使用Spring,则可以直接使用其org.springframework.web.context.ContextLoaderListener类,该类与上述功能大致相同,不同之处在于它们允许您使用contextConfigLocation上下文参数指定其xml配置文件。 这就是典型的基于Spring MVC的应用程序的配置方式。 设置完成后,您可以像上面给出的Spring xml示例一样尝试我们的POJO服务以进行测试。 您应该在记录器的输出中看到我们的服务正在运行。

    PS:实际上,我们在此描述的只是与Servlet Web应用程序相关,而不与JEE有关。 因此,您也可以使用Tomcat服务器。

    服务生命周期的重要性及其在现实世界中的使用

    我在这里提供的所有信息都不是新颖的,也不是杀手级的设计模式。 实际上,它们已在许多流行的开源项目中使用。 但是,根据我过去的工作经验,人们总是设法使这些变得极为复杂,更糟糕的情况是,他们在编写服务时完全无视生命周期的重要性。 的确,并非您要编写的所有内容都需要安装到服务中,但是,如果发现需要,请务必注意它们,并请注意它们会被正确调用。 您想要的最后一件事是退出JVM,而不清理您为其分配了宝贵资源的服务。 如果允许您在部署过程中动态地重新加载应用程序而不退出JVM,这些操作将变得更加灾难性,这将导致系统资源泄漏。

    以上服务实践已在TimeMachine项目中使用。 实际上,如果您查看timemachine.scheduler.service.SchedulerEngine ,它将只是许多运行在一起的服务的容器。 这就是用户可以通过编写Service来扩展调度程序功能的方式。 您可以通过一个简单的属性文件动态加载这些服务。

    参考: 如何A Programmer's Journal博客上从我们的JCG合作伙伴 Zemian Deng 编写更好的POJO服务


    翻译自: https://www.javacodegeeks.com/2012/09/how-to-write-better-pojo-services.html

    pojo类继承pojo类

    展开全文
  • POJO类与BO类

    2019-02-27 11:24:01
    POJO类:简单的实体类; BO类:当一个POJO类不满足需求而需要额外添加属性 时创建的带有该POJO类以及需求属性的实体类(使用时 ,需在方法中同时使用BO类与POJO类去接住jsp页面传 来的值,然后再将POJO类赋值给BO类...

    POJO类:简单的实体类;
    BO类:当一个POJO类不满足需求而需要额外添加属性

    时创建的带有该POJO类以及需求属性的实体类(使用时

    ,需在方法中同时使用BO类与POJO类去接住jsp页面传

    来的值,然后再将POJO类赋值给BO类中的实体属性)

    实例:

    POJO类:

    BO类:

    Controller层:

    jsp的ajax传值:

    展开全文
  • 数据转换为pojo类

    2021-04-05 16:56:06
    作者daniel-martins-IR,源码Specter,Specter是一个简单的方法来有效数据转换为pojo类,也是一个实现了数据转移到Pojo
  • SSM项目实战pojo类

    2017-10-16 11:10:56
    本资源为博客中ssm项目实战第二天需要用到的pojo类的压缩包,包含该项目所有的pojo类
  • java pojo类

    千次阅读 2018-07-03 22:03:09
    java pojo类POJO POJO是Plain OrdinaryJava Object的缩写 可以当作简单的Java对象 实际就是普通JavaBeans 外文名POJO实际意义普通JavaBeans全 称Plain Ordinary Java Object特 点支持业务逻辑的协助类中文释义...

    POJO

      POJO是Plain OrdinaryJava Object的缩写

      可以当作简单的Java对象

      实际就是普通JavaBeans

      

    外文名POJO实际意义普通JavaBeans
    全    称Plain Ordinary Java Object特    点支持业务逻辑的协助类
    中文释义简单的Java对象  

     

     

     

     

    POJO类中有属性和get、set方法,但是没有业务逻辑

    /**
     * POJO类代码示例
     */  
    public class UserInfoPojoDemo {
    
        private int userId;// 用户帐号
        private String pwd;// 用户密码
    
        /**
         * Constructor
         */
        public UserInfoPojoDemo() {
        }
        
        public UserInfoPojoDemo(String pwd) {
            this.pwd = pwd;
        }
    
        public UserInfoPojoDemo(int userId) {
            this.userId = userId;
        }
    
        public UserInfoPojoDemo(int userId, String pwd) {
            this.userId = userId;
            this.pwd = pwd;
        }
    
        /**
         *Access 
         */
        public int getUserId() {
            return userId;
        }
    
        public void setUserId(int userId) {
            this.userId = userId;
        }
    
        public String getPwd() {
            return pwd;
        }
    
        public void setPwd(String pwd) {
            this.pwd = pwd;
        }
    
    }

    展开全文
  • pojo类对应的就是数据库中的表,pojo类属性类型一定要用包装类Integer等 pojo类对应的就是数据库中的表,pojo类属性类型一定要用包装类Integer等 pojo类对应的就是数据库中的表,pojo类属性类型一定要用包装类...
  • Java pojo类

    2018-08-27 21:40:36
    POJO(Plain Ordinary Java Object)简单的Java对象...pojo类中有一些属性及其getter setter方法的类(并不是只有getting setting方法),没有业务逻辑。 例如: public class Category { private int id; priva...
  • POJO类的创建

    千次阅读 2016-03-02 16:44:11
    什么是pojo类pojo类是一个简单的java对象,也是一个普通的javabean。全称为Plain Odinary Java Object.pojo类和javaBean的区别 摘自百度百科 POJO 和JavaBean是我们常见的两个关键字,一般容易混淆,POJO全称是...
  • java中的POJO类

    千次阅读 2019-03-12 09:43:09
    查自百度百科,保存以便...POJO实质上可以理解为简单的实体类,顾名思义POJO类的作用是方便程序员使用数据库中的数据表,对于广大的程序员,可以很方便的将POJO类当做对象来进行使用,当然也是可以方便的调用其get,...
  • 做Maven项目工程时,往往需要使用Pojo类来封装查询的sql信息 PojoCreator4j可以解决需要不断手敲字段的机械录入工作特别适用于字段多、类型多、数据表多的情况
  • title: 关于反射的属性直接访问与pojo、json date: 2020-03-06 17:16:51 tags: [反射与框架, Java] ...直接访问设置好的pojo类 package my; import java.lang.reflect.Type; import af.test.Example; import ja...
  • pojo类注意事项

    2019-09-12 07:23:41
    1, POJO类中布尔类型的变量,都不要加is ,否则部门框架解析会引起序列化错误。 反例:定义为基本数据类型 boolean isSuccess ; 的属性,它的方法也是 isSuccess() ,RPC框架在反向解析的时候, 以为 对应的 属性名称...
  • JavaBean 和 pojo类区别

    2020-09-21 14:02:22
    而如果在pojo类里面再实现Serializable序列化接口,那就是javabean了。pojo和javabean的区别只在于是否实现了Serializable接口,即该类或对象是否可序列化。通常,要让一个对象能够在网络传输,就必须让该对象变成...
  • POJO类 domain类 javabean 详解

    千次阅读 2012-10-04 23:51:11
    POJO类 domain类 javabean 详解 什么是POJO  在使用hibernate时,要求和数据库的某张表相互映射的那个java类, 是一个POJO类,一般放在com.xxx.domain包下,POJO类翻译过来就是: 简单的Java对象...
  • POJO类toString()方法

    2020-04-26 10:03:50
    说明:[强制] POJO类必须写toString(),如果继承了另一个POJO类,注意前面加一下super.toString() ; 在方法抛出异常的时候,可以直接调用POJO的toString()方法打印其属性值,便于排查问题 推荐[Maven: org.project...
  • JAVA 标准的POJO类

    2020-01-22 21:05:55
    定义一个“标准的POJO类” POJO:plain old java object 1.所有的成员变量都需要使用private关键字私有化。 2.为每一个成员变量编写一对Getter Setter方法。 3.编写一个无参数的构造方法。 4.编写一个全参数的构造...
  • mybatis传递pojo类学习

    2018-12-13 10:21:48
    编写过程中报错 发现是mapper映射器给...首先是建立pojo类 package com.sjq.mybatis.pojo; public class User implements Serializable{ private static final long serialVersionUID = 1L; private Intege...
  • pojo类中有实体类属性,insert报错 参考 pojo类 public class Dialoges implements Serializable { int id; String orderType; int orderId; User fromUser; User toUser; String mes; private Dat...
  • 什么是pojo类pojo类是一个简单的java对象,也是一个普通的javabean。全称为Plain Odinary Java Object.pojo类和javaBean的区别摘自百度百科 POJO 和JavaBean是我们常见的两个关键字,一般容易混淆,POJO全称是Plain...
  • Hibernate中POJO类的状态

    2020-05-05 13:20:34
    POJO类所处的状态 POJO类所处的状态有三种: 瞬时态(Transient):对象保存在内存之中,并没有在数据库之中进行存储。也就是说如果对像一直没有存储,那么就有可能被GC回收,回收之后就象不存在一样。 持久态...
  • 根据JSON文件自动生成Java POJO类(Java Bean)源文件本文介绍使用程序jsonschema2pojo来自动生成Java的POJO类源文件,本文主要使用maven,其他构建工具请参考官方文档。jsonschema2pojo 基本介绍jsonschema2pojo是一...
  • mybatis 查询结果返回 list<pojo> 和 一个 pojo 的一些坑
  • 今天跟大家分享的是通过java中的反射,获取pojo类的所有字段值。为什么要做这个操作的呢?主要是为了重写实体类的toString方法。有人会说,直接重写toString方法,返回字段.toString()的字符串不就行了。这么做的确...
  • 利用Idea中Gson插件快速编辑POJO类 (1)需求说明 现在有一个hashmap,想写一个POJO类实现它所有字段的get、set方法,当hashmap中字段较多的时候,过程会变成很繁琐的体力活,综上所述可以使用idea中的Gson插件快速...
  • pojo类转换成json的工具类
  • 3.POJO类中的成员变量类型必需为封装类。 4.seter和geter方法方法名就是在成员变量名首字母大写后加上set或get。 5.如果要使用延迟加载,POJO类必需继承com.jplus.basetable.BaseTable。 6.如果要使用延迟加载,...
  • SQL查询数据,通过反射获取POJO类字段名,拼接方法名调用getter和setter方法,存入数据。 方便查看,异常均抛出 # 一、POJO类 public class Student { private String sno; private String sname; public ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,842
精华内容 4,736
关键字:

pojo类