精华内容
下载资源
问答
  • 前言:随着一个项目规模的增大,我们不得不引入许多Java bean对象,而这些对象一般来说是在Spring的配置文件applicationContext.xml中进行配置的,这样就声明了这是一个由Spring容器管理的bean对象。这种做法必然会...

    前言:随着一个项目规模的增大,我们不得不引入许多Java bean对象,而这些对象一般来说是在Spring的配置文件applicationContext.xml中进行配置的,这样就声明了这是一个由Spring容器管理的bean对象。这种做法必然会导致Spring的配置文件的可读性很差。在Spring中,我们有一些小技巧可以避免这种情况。这就是本篇文章所讨论的。

    一、定义bean的三种途径:

    首先编写Student和Teacher两个类

    test/Student.java

    publicclassStudent {

    privateString name;

    privateTeacher teacher;

    publicString getName() {

    returnname;

    }

    publicvoidsetName(String name) {

    this.name = name;

    }

    publicTeacher getTeacher() {

    returnteacher;

    }

    publicvoidsetTeacher(Teacher teacher) {

    this.teacher = teacher;

    }

    }

    test/Teacher.java

    publicclassTeacher {

    privateString name;

    publicString getName() {

    returnname;

    }

    publicvoidsetName(String name) {

    this.name = name;

    }

    }

    方法一:基于XML的bean定义(需要提供setter方法)

    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">

    publicclassMain {

    publicstaticvoidmain(String args[]){

    FileSystemXmlApplicationContext context=newFileSystemXmlApplicationContext("applicationContext.xml的绝对路径");

    Student student= (Student) context.getBean("student");

    Teacher teacher= (Teacher) context.getBean("teacher");

    System.out.println("学生的姓名:"+student.getName()+"。老师是"+student.getTeacher().getName());

    System.out.println("老师的姓名:"+teacher.getName());

    }

    }

    方法二:基于注解的bean定义(不需要提供setter方法)

    Spring为此提供了四个注解,这些注解的作用与上面的XML定义bean效果一致,在于将组件交给Spring容器管理。组件的名称默认是类名(首字母变小写),也可以自己修改:

    @Component:当对组件的层次难以定位的时候使用这个注解

    @Controller:表示控制层的组件

    @Service:表示业务逻辑层的组件

    @Repository:表示数据访问层的组件

    使用这些注解的时候还有一个地方需要注意,就是需要在applicationContext.xml中声明一项,指明Spring容器扫描组件的包目录。

    @Component("teacher")

    publicclassTeacher {

    @Value("李四")

    privateString name;

    publicString getName() {

    returnname;

    }

    }

    @Component("student")

    publicclassStudent {

    @Value("张三")

    privateString name;

    @Resource

    privateTeacher teacher;

    publicString getName() {

    returnname;

    }

    publicTeacher getTeacher() {

    returnteacher;

    }

    }

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:context="http://www.springframework.org/schema/context"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context.xsd">

    publicclassMain {

    publicstaticvoidmain(String args[]){

    FileSystemXmlApplicationContext context=newFileSystemXmlApplicationContext("applicationContext.xml的绝对路径");

    Student student= (Student) context.getBean("student");

    Teacher teacher= (Teacher) context.getBean("teacher");

    System.out.println("学生的姓名:"+student.getName()+"。老师是"+student.getTeacher().getName());

    System.out.println("老师的姓名:"+teacher.getName());

    }

    }

    方法三:基于Java类的bean定义(需要提供setter方法)

    @Configuration

    publicclassBeansConfiguration {

    @Bean

    publicStudent student(){

    Student student=newStudent();

    student.setName("张三");

    student.setTeacher(teacher());

    returnstudent;

    }

    @Bean

    publicTeacher teacher(){

    Teacher teacher=newTeacher();

    teacher.setName("李四");

    returnteacher;

    }

    }

    publicclassMain {

    publicstaticvoidmain(String args[]){

    AnnotationConfigApplicationContext context=newAnnotationConfigApplicationContext(BeansConfiguration.class);

    Student student= (Student) context.getBean("student");

    Teacher teacher= (Teacher) context.getBean("teacher");

    System.out.println("学生的姓名:"+student.getName()+"。老师是"+student.getTeacher().getName());

    System.out.println("老师的姓名:"+teacher.getName());

    }

    }

    二、Spring的自动注入

    Spring提供了五种自动装配的类型

    no:顾名思义, 显式指明不使用Spring的自动装配功能

    byName:根据属性和组件的名称匹配关系来实现bean的自动装配

    byType:根据属性和组件的类型匹配关系来实现bean的自动装配,有多个适合类型的对象时装配失败

    constructor:与byType类似是根据类型进行自动装配,但是要求待装配的bean有相应的构造函数

    autodetect:利用Spring的自省机制判断使用byType或是constructor装配

    基于XML的自动装配

    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">

    这里我并没有显式为Student对象注入Teacher属性,而是使用autowired="byName"代替,这样一来Spring会帮我们处理这些细节,将名字是teacher的组件注入到Student对象中。

    基于注解的自动装配

    其实上面已经应用过了,这里再提一下@Resource和@Autowired的区别。@Resource默认是使用byName进行装配,@Autowired默认使用byType进行装配。

    @Component("teacher")

    publicclassTeacher {

    @Value("李四")

    privateString name;

    publicString getName() {

    returnname;

    }

    publicvoidsetName(String name) {

    this.name = name;

    }

    }

    @Component("student")

    publicclassStudent {

    @Value("张三")

    privateString name;

    @Resource

    privateTeacher teacher;

    publicString getName() {

    returnname;

    }

    publicvoidsetName(String name) {

    this.name = name;

    }

    publicTeacher getTeacher() {

    returnteacher;

    }

    publicvoidsetTeacher(Teacher teacher) {

    this.teacher = teacher;

    }

    }

    三、如何进行选择?

    其实说了这么多,我们应该如何对这些不同方式进行权衡和选择呢?这个见仁见智,我说说我常用的方式。

    定义bean:一般我使用基于注解的bean定义。这样可以摆脱使用XML或是Java类对大量bean进行配置的噩梦,让程序变得简洁。注解还可以清楚地指明组件所在的层次。但是也有特殊的情况,比如说配置数据源,也许某个组件并不是你写的(来自于Spring或是第三方jar包里面的组件等),你没有办法在这些组件里面加上这些注解使之成为Spring容器管理的bean(别人也不会为你加上这些注解,因为他们不知道你会使用到哪些组件)。这种情况下就得使用XML或是Java类进行配置了,个人比较喜欢XML配置。如下例子:

    自动装配:一般我使用基于注解的自动装配。同样也是为了减少XML配置文件的“篇幅”。

    通过使用基于注解的bean定义和自动装配,大大减少了XML配置文件的长度,增加了程序的可读性。

    展开全文
  • Spring 系列教程前面介绍了Bean的XML配置方法,从Spring 3.0开始,可以使用java代码配置Bean,替代XML配置。...Java配置也会用到一些注解,主要有:@Configuration、@ComponentScan@Bean。1. 通过@Configura...

    Spring 系列教程

    前面介绍了Bean的XML配置方法,从Spring 3.0开始,可以使用java代码配置Bean,替代XML配置。

    Java配置与注解配置不同,Java配置是把Java代码文件当作配置文件,注解配置是在实际Java类中使用注解设置依赖关系。

    Java配置也会用到一些注解,主要有:@Configuration、@ComponentScan和@Bean。

    1. 通过@Configuration注解创建Java配置类

    @Configuration注解标注的类是配置类,用于配置Bean之间依赖关系。

    @Import注解允许从另一个配置Java/XML文件加载bean定义。

    示例:SpringConfig.java

    package com.qikegu.demo.config;

    import org.springframework.context.annotation.Configuration;

    import org.springframework.context.annotation.ComponentScan;

    @Configuration // 表明这是个Bean的Java配置类

    public class SpringConfig {

    }

    2. 通过@Bean注解定义Bean

    要定义一个Bean,可以通过:

    给一个方法加@Bean注解

    方法返回Bean实例

    Spring容器会注册这个Bean,并将方法名作为Bean ID。

    示例:SpringConfig.java

    package com.qikegu.demo.config;

    import org.springframework.context.annotation.Bean;

    import org.springframework.context.annotation.Configuration;

    @Configuration

    public class SpringConfig {

    // 定义 App Bean

    @Bean(initMethod = "init", destroyMethod = "close" ) // 指定初始化回调,销毁回调

    @Scope("prototype") // 设置Bean作用域

    public App app() { // Bean ID = app

    return new App(); // 返回App Bean

    }

    }

    3. 注入Bean依赖关系

    可以通过让一个Bean方法调用另一个Bean方法注入依赖项。

    示例:SpringConfig.java

    package com.qikegu.demo.config;

    import org.springframework.context.annotation.Bean;

    import org.springframework.context.annotation.Configuration;

    @Configuration

    public class SpringConfig {

    // 定义 App Bean

    @Bean

    public App app() {

    return new App(logger()); // 调用Bean方法logger()注入Logger Bean实例

    }

    /* @Bean

    public App app() {

    App app = new App();

    Service[] services = {database(), logger(), mail()};

    app.setServices(services);

    app.setMainService(services[1]);

    app.setId(1234);

    return app;

    } */

    // 定义 Database Bean

    @Bean

    public Database database() {

    return new Database();

    }

    // 定义 Logger Bean

    @Bean

    public Logger logger() {

    return new Logger();

    }

    // 定义 Mail Bean

    @Bean

    public Mail mail() {

    return new Mail();

    }

    }

    4. 读取配置类

    可以使用AnnotationConfigApplicationContext读取配置类。

    示例:Test.java

    package com.qikegu.demo.config;

    import org.springframework.context.ApplicationContext;

    import org.springframework.context.annotation.AnnotationConfigApplicationContext;

    public class Test {

    public static void main(String[] args) {

    // 使用`AnnotationConfigApplicationContext`读取配置类

    ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);

    }

    }

    5. 通过Spring容器获取bean

    示例:

    App app = context.getBean("app", App.class);

    展开全文
  • JAXB(Java Architecture for XML Binding) 是一个业界的标准,可以根据XML Schema产生Java类的...JAXB提供了快速而简便的方法将XML模式绑定到Java表示,从而使得Java开发者在Java应用程序中能方便地结合XML数据处...

    JAXB(Java Architecture for XML Binding) 是一个业界的标准,可以根据XML Schema产生Java类的技术。该过程中,JAXB也提供了将XML实例文档反向生成Java对象树的方法,并能将Java对象树的内容重新写到XML实例文档。JAXB提供了快速而简便的方法将XML模式绑定到Java表示,从而使得Java开发者在Java应用程序中能方便地结合XML数据和处理函数。

    一、JAXB API介绍

    ① 常用API

    • JAXBContext类,是应用的入口,通过该类创建序列化和反序列化对象,也即编组对象和解组对象;
    • Marshaller 编组接口,将Java对象序列化为XML数据;
    • Unmarshaller 解组接口,将XML数据反序列化为Java对象。

    ② 常用注解

    • @XmlRootElement,将Java类或枚举映射成XML元素根节点,是唯一一个必须注解,name属性指定根节点名称,不指定默认为类名的小写;
    • @XmlElement,将Java类的一个属性映射为XML节点元素,name属性可自定义元素名;
    • @XmlAttribute,将Java类的一个属性映射为XML节点元素的属性,name属性可自定义属性名;
    • @XmlType,将Java类或枚举类型映射到XML模式类型,常与@XmlRootElement、@XmlAccessorType共用,propOrder属性定义字段生成的XML节点顺序;
    • @XmlAccessorType,控制字段或属性的序列化。属性XmlAccessType有4个常量值:FIELD表示JAXB将自动绑定Java类中的每个非静态的(static)、非瞬态的(由@XmlTransient标注)字段到XML;PROPERTY表示java对象中所有通过getter/setter方式绑定成属性到XML;PUBLIC_MEMBER表示Java对象中所有的public访问权限的成员变量和通过getter/setter方式访问的成员变量,该值为默认值;NONE表示Java对象的所有属性都不映射为XML的元素;
    • @XmlAccessorOrder,控制JAXB 绑定类中属性和字段的排序,有两个属性,AccessorOrder.ALPHABETICAL——对生成的XML元素按字母书序排序,XmlAccessOrder.UNDEFINED——不排序,默认为该值;
    • @XmlJavaTypeAdapter,自定义适配器(即扩展抽象类XmlAdapter并覆盖marshal()和unmarshal()方法),解决日期(Date),数字(Number)格式化问题;
    • @XmlElementWrapper ,对于数组或集合(即包含多个元素的成员变量),生成一个包装该数组或集合的XML元素(称为包装器),该注解只能用在集合上;
    • @XmlTransient ,用于标示在由Java对象映射XML时,忽略此属性,在生成的XML文件中将不出现此元素。

    ③ 实际应用中注意的问题

    •  如果JavaBean中定义了有参的构造器,那么必须同时定义无参构造器,否则转XML会抛无默认构造函数的异常;
    • 成员变量值为NULL时,将不会映射成对应的XML元素——由于基本数据类型默认值不为空,所以基本数据类型不设值也会映射成XML元素,值为默认值,所以如果模型需要基本数据,在属性定义的时候尽量使用包装类型;
    • @XmlAccessorType 注解中如果属性值为XmlAccessType.FIELD,则表示通过成员变量来映射,set/get方法上的映射注解就是多余的,所以如果此时set/get方法上再标注元素或者属性映射注解,将抛属性重复性异常;属性值为XmlAccessType.NONE不映射为XML元素的前提是Java字段或set/get方法上都没有映射注解;
    • @XmlType propOrder属性能够自定义字段的排序,该属性如果设置,要么写成{}的形式,否则在就必须将所有@XmlElement标注或者没有@XmlElement标注的但实际上会被映射为XML节点的字段添加到排序列表,不然会抛异常;如果propOrder属性设置有值,@XmlAccessorOrder注解的元素排序规则将失效;

     二、JAXB的具体实践

    Bean转Xml和Xml转Bean的工具类

    import com.sun.xml.internal.bind.marshaller.CharacterEscapeHandler;
    import com.xiaomi.mifi.scf.abc.errors.ABCException;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.http.converter.HttpMessageConversionException;
    import org.springframework.util.Assert;
    
    import javax.xml.bind.JAXBContext;
    import javax.xml.bind.JAXBException;
    import javax.xml.bind.Marshaller;
    import javax.xml.bind.Unmarshaller;
    import javax.xml.bind.annotation.XmlAnyElement;
    import java.io.StringReader;
    import java.io.StringWriter;
    import java.util.Collection;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentMap;
    
    
    public final class XmlUtil {
        private static final ConcurrentMap<Class, JAXBContext> JAXB_TMP = new ConcurrentHashMap<>();
    
        public static String objectToXml(Object root) {
            Class clazz = root.getClass();
            return objectToXml(root, clazz, null);
        }
    
        public static String objectToXml(Object root, String encoding) {
            Class clazz = root.getClass();
            return objectToXml(root, clazz, encoding);
        }
    
        private static String objectToXml(Object root, Class clazz, String encoding) {
            try {
                StringWriter writer = new StringWriter();
                createMarshaller(clazz, encoding).marshal(root, writer);
                return writer.toString();
            } catch (JAXBException e) {
                throw new ABCException(e);
            }
        }
    
        // 对于有父类的子类,反序列化不能用这种方式,因为解析出来的是父类基本类,无法强转到子类
        public static <T> T xmlToObject(String xml, Class<T> clazz) {
            try {
                StringReader reader = new StringReader(xml);
                return (T) createUnmarshaller(clazz).unmarshal(reader);
            } catch (JAXBException e) {
                throw new ABCException(e);
            }
        }
    
        // 对上一个方法的补充,解析到父类后会继续解析到子类
        public static <T, S> T xmlToObject(String xml, Class<S> fatherClazz, Class<T> clazz) {
            try {
                StringReader reader = new StringReader(xml);
                return (T) getJaxbContext(fatherClazz, clazz).createUnmarshaller().unmarshal(reader);
            } catch (Exception e) {
                throw new ABCException(e);
            }
        }
    
        private static Marshaller createMarshaller(Class clazz, String encoding) throws JAXBException {
            JAXBContext jaxbContext = getJaxbContext(clazz);
            Marshaller marshaller = jaxbContext.createMarshaller();
            // xml格式
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
    
            // 去掉生成xml的默认报文头
            marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);
    
            // 不进行转义字符的处理
            marshaller.setProperty(CharacterEscapeHandler.class.getName(), (CharacterEscapeHandler) (ch, start, length, isAttVal, writer) -> writer.write(ch, start, length));
    
            if (StringUtils.isNotBlank(encoding)) {
                marshaller.setProperty(Marshaller.JAXB_ENCODING, encoding);
            }
            return marshaller;
        }
    
        private static Unmarshaller createUnmarshaller(Class clazz) throws JAXBException {
            JAXBContext jaxbContext = getJaxbContext(clazz);
            return jaxbContext.createUnmarshaller();
        }
    
        private static JAXBContext getJaxbContext(Class clazz) {
            Assert.notNull(clazz, "'clazz' must not be null");
            JAXBContext jaxbContext = JAXB_TMP.get(clazz);
            if (jaxbContext == null) {
                try {
                    jaxbContext = JAXBContext.newInstance(clazz, CollectionWrapper.class);
                    JAXB_TMP.putIfAbsent(clazz, jaxbContext);
                } catch (JAXBException ex) {
                    throw new HttpMessageConversionException("Could not instantiate JAXBContext for class [" + clazz
                            + "]: " + ex.getMessage(), ex);
                }
            }
            return jaxbContext;
        }
    
        private static JAXBContext getJaxbContext(Class fatherClazz, Class clazz) {
            Assert.notNull(clazz, "'clazz' must not be null");
            JAXBContext jaxbContext = JAXB_TMP.get(clazz);
            if (jaxbContext == null) {
                try {
                    jaxbContext = JAXBContext.newInstance(fatherClazz, clazz, CollectionWrapper.class);
                    JAXB_TMP.putIfAbsent(clazz, jaxbContext);
                } catch (JAXBException ex) {
                    throw new HttpMessageConversionException("Could not instantiate JAXBContext for class [" + clazz
                            + "]: " + ex.getMessage(), ex);
                }
            }
            return jaxbContext;
        }
    
        private static class CollectionWrapper {
            @XmlAnyElement
            protected Collection<?> collection;
        }
    
    }

    定义java实体:

    @Data
    @XmlAccessorType(XmlAccessType.FIELD)
    @XmlRootElement(name = "ap")
    public class ABCBaseRespData implements Serializable {
    
        private static final long serialVersionUID = 8922189936461538311L;
    
        /**
         * 交易代码 C6
         */
        @XmlElement(name = "CCTransCode")
        private String cCtransCode;
    
        @XmlElement(name = "Cmp")
        private ABCBaseFiledData filedData;
    
        @Data
        @XmlAccessorType(XmlAccessType.FIELD)
        public static class ABCBaseFiledData implements Serializable {
    
            /**
             * <Cme>
             * <RecordNum>记录数</RecordNum>
             * <FieldNum>字段数</FieldNum>
             * </Cme>
             */
            @XmlElement(name = "RecordNum")
            private int recordNum;
    
            /** */
            @XmlElement(name = "fieldNum")
            private int fieldNum;
        }
    }
    
    import lombok.Data;
    
    import javax.xml.bind.annotation.XmlAccessType;
    import javax.xml.bind.annotation.XmlAccessorType;
    import javax.xml.bind.annotation.XmlElement;
    import javax.xml.bind.annotation.XmlRootElement;
    
    @Data
    @XmlAccessorType(XmlAccessType.FIELD)
    @XmlRootElement(name = "ap")
    public class ABCPayResultResp extends ABCBaseRespData {
        @XmlElement(name = "Cmp")
        private TransStatus transStatus;
    
        @Data
        @XmlAccessorType(XmlAccessType.FIELD)
        public static class TransStatus{
            /** 流水状态,参考TransStatusEnum*/
            @XmlElement(name = "TransSta")
            private String transSta;
        }
    
    }
    

    测试用例:

     

    展开全文
  • xml中声明自定义的bean和引入bean引入bean中的内容,自定义bean代码随意package com.shiro.utils;import org.springframework.beans.BeansException;import org.springframework.beans.factory....

    xml中声明自定义的bean和引入bean

    引入bean中的内容,自定义bean代码随意

    package com.shiro.utils;

    import org.springframework.beans.BeansException;

    import org.springframework.beans.factory.NoSuchBeanDefinitionException;

    import org.springframework.context.ApplicationContext;

    import org.springframework.context.ApplicationContextAware;

    /**

    * 上下文util

    * @author eadela

    *

    */

    public class SpringContextUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override

    public void setApplicationContext(ApplicationContext applicationContext)

    throws BeansException {

    SpringContextUtil.applicationContext = applicationContext;

    }

    public static ApplicationContext getApplicationContext() {

    return applicationContext;

    }

    public static Object getBean(String name) throws BeansException {

    try {

    return applicationContext.getBean(name);

    } catch (Exception e) {

    throw new RuntimeException("获取的Bean不存在!");

    }

    }

    public static T getBean(String name, Class requiredType)

    throws BeansException {

    return applicationContext.getBean(name, requiredType);

    }

    public static boolean containsBean(String name) {

    return applicationContext.containsBean(name);

    }

    public static boolean isSingleton(String name)

    throws NoSuchBeanDefinitionException {

    return applicationContext.isSingleton(name);

    }

    public static Class extends Object> getType(String name)

    throws NoSuchBeanDefinitionException {

    return applicationContext.getType(name);

    }

    public static String[] getAliases(String name)

    throws NoSuchBeanDefinitionException {

    return applicationContext.getAliases(name);

    }

    }

    在需要的地方引入自定义bean

    public class CusUtil {

    final static CustomBean cus = SpringContextUtil.getBean("customBean", CustomBean.class);

    }这样在CusUtil中就可以引用CustomBean 内的内容

    展开全文
  • 在javaEE开发中,我们在支持Hibernate之后,想使用Myeclipse自动生成java的Bean和BeanName.hbm.xml文件(Oracle12c为例): 注:以下提到"BeanName"为您使用的java class name。 1:创建一个java项目让他支持Hibernate...
  • JAVA-bean和jar文件

    2010-03-14 10:40:01
    2)属性,bean的特征,可通过这些属性的setget方法来改变它们 3)方法,通过这些操作与bean交互,是bean定义的方法 2.JAR文件是一个独立于平台的文件格式,可将许多文件集合成一个文件。 ...
  • spring的bean管理(注解)注解写法:@注解名称(属性名称=属性值)注解使用在类上面,方法上面属性上面Spring注解开发的准备导入基本jar包,与spring的bean管理(配置文件)的那一章节引用相同;导入aop的jar包创建类,...
  • 使用工具可以自动生成mybatis的mapper.xml、Mapper.java和相应的bean
  • Spring 系列教程前面介绍了Bean的XML配置方法,从Spring 3.0开始,可以使用java代码配置Bean,替代XML配置。...Java配置也会用到一些注解,主要有:@Configuration、@ComponentScan@Bean。1. 通过@Configura...
  • 1.Spring工厂类的继承方式从上面可以看出,创建工厂类,可以通过ClassPathXmlApplicationContextFileSystemXmlApplicationContext这两种方式:FileSystemXmlApplicationContext从磁盘加载配置文件,此时就需要使用...
  • java和xml相互转换,java bean转xml文件

    千次阅读 2014-11-02 11:43:35
    一、前言。  最近正在做一个项目,根据需求计划需要一种 Object XML的工具,而JAXB就非常... Java Architecture for XML Binding (JAXB)是一个业界的标准,是一项可以根据XML Schema产生Java类的技术。该过程中,
  • 动态创建修改Spring的bean配置文件2014/8/6 21:48:46 tomhat 程序员俱乐部 我要评论(0)摘要:1、如果只是创建一个XML文件,那么只需要导入dom4j-1.6.1.jar就可以了,路径如下:spring-framework-2.5.6\lib\dom4j\...
  • 6、使用javaConfig代替xml文件来声明导入bean在这之前的教程中,都是使用xml文件(即bean配置文件)来对bean进行声明的,但是在spring 3.0版本以及后续更新的版本中,提供了javaConfig的方式(即注解)来声明bean...
  • 与XmlAnnotation两种配置方式不同点在于:前两种XmlAnnotation的配置方式为预定义方式,即开发人员通过 XML 文件或者 Annotation 预定义配置 bean 的各种属性后,启动 spring 容器,Spring ...
  • JAVA Bean和XML之间的相互转换 - XStream简单入门背景介绍我们在工作中经常 遇到文件解析为数据或者数据转化为xml文件的情况,之前我一直采用的方式都是手动的来解析或拼接XML文件,这个做法固然是可以的,但是代码部分...
  • 用Dom4jSAX两种方式将如下配置文件解析成java Bean对象。配置文件(config.xml)如下:   首先定义java的三个类Beans、Bean、Fie
  • 本节内容如下:一、操作变量二、操作属性 三、自定义函数四、引用外部java文件五、引用外部class文件六、引用外部Jar包七、其它用法(接受参数, log等)一、操作变量:通过使用Bean shell内置对...
  • 我想使用spring配置文件来自定义bean注入,这样对于profile devtest我将有一个bean实现,而对于profile prod,我将有另一个.问题是如何实现这一目标.如何设置一个bean在两个不同的配置文件中处于活动状态.我试过这样...
  • 根据JSON文件自动生成Java POJO类(Java Bean)源文件本文介绍使用程序jsonschema2pojo来自动生成Java的POJO类源文件,本文主要使用maven,其他构建工具请参考官方文档。jsonschema2pojo 基本介绍jsonschema2pojo是一...
  • 使用 Java 配置进行 Spring bean 管理 学习使用 Java 配置管理 Spring bean 概述 众所周知,Spring 框架是控制反转 (IOC) 或依赖性注入 (DI) 模式的...尽管使用 XML 配置较为简单便捷,但仍有另外一种方法可定义 bean
  • 如果同时使用了xml配置,和java类的bean配置(当然估计项目中一般不会这样), 在初始化容器指定资源文件的时候可能会比较麻烦 此时我们可以把基于java类的bean配置整合到xml中,或xml的配置整合到java类的配置中 1...
  • Spring Boot学习笔记(五):我们已经...下面就来介绍:Spring Boot 配置文件中的值,如何注入到我们自定义的 Java Bean 中。(或者:Java Bean 如何获取配置文件中的值来注入) 如下分别为 Java Bean yml 配置...
  • Java Spring-Bean

    2019-10-06 21:06:23
    Bean初始化销毁方法 配置初始化销毁的方法:* init-method=”setup”* destroy-method=”teardown”执行销毁的时候,必须手动关闭工厂,而且只对scope=” singleton ”(也就是默认值)有效。 配置文件: &...
  • 以前通常会把java bean list 输出为EXCEL文件,作为报表供客户下载,有时候也需要读入客户准备好的Excel文档,并将这些数据导入到数据库中,或者做其他处理, 一般来说导入 excel 文件到内存中应该比较容易,但jxls这...
  • 一、 Spring Auto Scanning Components —— 自动扫描组件通常你可以在xml配置文件中,声明一个bean或者component,然后Spring容器会检查注册你的bean或component。实际上,Spring支持自动扫描bean或component,你...
  • 利用Java反射机制Cache实现读取的优化的CSV读取器
  • 1、简介XStream是一个序列化JavaBean为XML文件以及反序列化的工具。2、准备2.1、XML回顾在学习这部分内容前,假设你对XML以及有一定的了解,至少能够分辨出XML的元素、属性、字段、包、系统属性、类型等等。例如有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,931
精华内容 1,572
关键字:

java文件和bean文件

java 订阅