精华内容
下载资源
问答
  • 1. 本帖内容 在用java作开发时,一般会选择使用xml文件作为配置文件,故而通过java工程读取配置文件则是必须掌握的知识;传统的C/C++通过File文件的方式或者说通过流的方式进行读写,过分的浪费内存与效率,且读写...

    1. 本帖内容

          在用java作开发时,一般会选择使用xml文件作为配置文件,故而通过java工程读取配置文件则是必须掌握的知识;传统的C/C++通过File文件的方式或者说通过流的方式进行读写,过分的浪费内存与效率,且读写及其不方便,不适用于java的灵活配置,而java的注解方式成功的解决了该问题。

           作者在从事相关的开发中学习了一下注解的方式,并成功开发了项目;虽然现在网上关于此知识已经铺天盖地,而我仍旧希望将自己的经验与大家分享。

    2. 选择要读取的配置文件

    下面的配置文件虽说是作者编纂,但仍可代表一般的配置,读者姑妄观之,见下

    <?xml version="1.0" encoding="UTF-8"?>
    <cham formatversion="1.14">
      <servers>
        <centers>
    	  <center id="1" name="center1">
    	    <main>
    		  <iphost>127.0.0.1</iphost>
    		  <port>8443</port>
    		  <byte-sequence>BigEndian</byte-sequence>
    		</main>
    		<preparation>
    		  <iphost>10.10.10.1</iphost>
    		  <port>8080</port>
    		  <byte-sequence>BigEndian</byte-sequence>
    		</preparation>
    		<argument-ref>ccsArg</argument-ref>
    	  </center>
    	</centers>
      </servers>
    </cham>

    上文中的配置文件格式是标准的配置文件格式,配置文件中其实只包含了一个数组,记<centers></centers>节点,而我们此次的主要目的也是讲解该节点。

    3. 基本注解讲解

    从严格意义上来讲,XML文件常用的注解共有四个:

    1) @XmlRootElement(name="")  用于注解根节点,即XML的起点

    2)@XmlAttribute(name="") 用于注释attribute,例如<center id="1" name="center1"/>中的id和name两个属性

    2)@XmlElement(name="") 最常用的注释方式,用于注释节点,例如<port>8080</port>

    4)@XmlTransient  用于放置在get方法上,放置报错。

    4. java相应文件的写作

    分析上述的cham.xml配置文件,很容易产清楚它的结构,它有以下几个部分组成

    1. cham.xml文件由一个<servers/>节点组成

    2. servers节点由<centers/>节点组成,而<centers/>节点是个数组,用于可以在其中配置多个<center/>,而本帖中只包含了一个元素。

    3. <center/>节点由两部分组成,即<main/><preparation/> 和 <argument-ref/>节点。

    我们的分析方式采用的由内及外的读取方式

    4.1 最基本的<main/>单元

    查看上述cham.xml文件,则可以发现<main/>和<preparation/>是最基本的配置单元,没有比它更小的单元了,我们不妨先从它开始注解

    我们可以建立一个名字叫做ServerPoint.java的文件来表示该节点

    package com.china.domain.config;
    
    import java.io.Serializable;
    
    import javax.xml.bind.annotation.XmlElement;
    import javax.xml.bind.annotation.XmlTransient;
    
    public class ServerPoint implements Serializable {
    
    	private static final long serialVersionUID = 3623939598540009923L;
    	
    	@XmlElement(name="iphost")
    	private String iphost;
    	
    	@XmlElement(name="port")
    	private int port;
    	
    	@XmlElement(name="byte-sequence")
    	private String byteSequence;
    
    	@XmlTransient
    	public String getIphost() {
    		return iphost;
    	}
    
    	public void setIphost(String iphost) {
    		this.iphost = iphost;
    	}
    
    	@XmlTransient
    	public int getPort() {
    		return port;
    	}
    
    	public void setPort(int port) {
    		this.port = port;
    	}
    
    	@XmlTransient
    	public String getByteSequence() {
    		return byteSequence;
    	}
    
    	public void setByteSequence(String byteSequence) {
    		this.byteSequence = byteSequence;
    	}
    
    	@Override
    	public String toString() {
    		return " [iphost=" + iphost + ", port=" + port + ", byteSequence=" + byteSequence + "]";
    	}
    }

    读者很容易看出来,该文件和之前<main/>或者<preparation/>节点的内容正好一一对应。所涉及的注释有两个,即@XmlElement 和 @XmlTransient,它们的功能此处不再赘述。

    4.2 <center/>节点讲解

    从之前的分析可以知道,<center/>节点共包含两个部分或者说三个部分,即<main/><preparation/>和 <argument-ref/>节点。从内容上看,需要用到的注释有三个,即@XmlElement 、@XmlAttribute 、@XmlTransient

    我们可以用一个Center.java 文件来表示该节点,如下所示:

    package com.china.domain.config;
    
    import java.io.Serializable;
    
    import javax.xml.bind.annotation.XmlAttribute;
    import javax.xml.bind.annotation.XmlElement;
    import javax.xml.bind.annotation.XmlTransient;
    
    public class Center implements Serializable {
    
    	private static final long serialVersionUID = 4568925940918840647L;
    	
    	@XmlAttribute(name="id")
    	private int id;
    	
    	@XmlAttribute(name="name")
    	private String name;
    	
    	@XmlElement(name="main")
    	private ServerPoint serverPoint;
    	
    	@XmlElement(name="preparation")
    	private ServerPoint back;
    	
    	@XmlElement(name="argument-ref")
    	private String argumentRef;
    
    	@XmlTransient
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	@XmlTransient
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	@XmlTransient
    	public ServerPoint getServerPoint() {
    		return serverPoint;
    	}
    
    	public void setServerPoint(ServerPoint serverPoint) {
    		this.serverPoint = serverPoint;
    	}
    
    	@XmlTransient
    	public ServerPoint getBack() {
    		return back;
    	}
    
    	public void setBack(ServerPoint back) {
    		this.back = back;
    	}
    
    	@XmlTransient
    	public String getArgumentRef() {
    		return argumentRef;
    	}
    
    	public void setArgumentRef(String argumentRef) {
    		this.argumentRef = argumentRef;
    	}
    
    	@Override
    	public String toString() {
    		return "Center [id=" + id + ", name=" + name + ", serverPoint=" + serverPoint + ", back=" + back
    				+ ", argumentRef=" + argumentRef + "]";
    	}
    }

    从上文中可以看出,用@XmlAttribute可以注释<center id="1" name="center1"/>的场景,由于代码和注释一一匹配,此处不再多言。

    4.3 <servers/>节点及数组的注释方式

    前面分析已知:<servers/>节点下是一个包含了多个(本例中只有一个)<center/>的<centers/>数组,则我们创建和<servers/>节点相对应的java文件时要考虑数组的因素。一般来讲,我们是通过@XmlElementWrapper 来注释数组,用法如下

    package com.china.domain.config;
    
    import java.io.Serializable;
    import java.util.Arrays;
    
    import javax.xml.bind.annotation.XmlElement;
    import javax.xml.bind.annotation.XmlElementWrapper;
    import javax.xml.bind.annotation.XmlTransient;
    
    public class Servers implements Serializable {
    
    	private static final long serialVersionUID = 8836963744878452510L;
    
    	@XmlElementWrapper(name="centers")//用于注释<centers/>数组,表示这是个数组
    	@XmlElement(name="center")//用于注释数组的子元素
    	private Center[] centers;
    
    	@XmlTransient
    	public Center[] getCenters() {
    		return centers;
    	}
    
    	public void setCenters(Center[] centers) {
    		this.centers = centers;
    	}
    
    	@Override
    	public String toString() {
    		return " [centers=" + Arrays.toString(centers) + "]";
    	}
    }
    

    4.4 注释根节点

    XML注释中有 @XmlRootElement(name="cham")注释根节点,其中 cham是xml文件根节点的名称,在本例中的name,即<cham formatversion="1.14"/>中的cham

    用@XmlAccessorType(XmlAccessType.FIELD)注解表示当前所注解内容的类型,除FIELD以外还有其他数种,但最长用的是FIELD,至于其他的含义,读者请搜索相关资料。

    我们可以创建一个名字叫做 SystemConfig.java的文件来存放该内容:

    package com.china.domain.config;
    
    import java.io.Serializable;
    
    import javax.xml.bind.annotation.XmlAccessType;
    import javax.xml.bind.annotation.XmlAccessorType;
    import javax.xml.bind.annotation.XmlAttribute;
    import javax.xml.bind.annotation.XmlElement;
    import javax.xml.bind.annotation.XmlRootElement;
    import javax.xml.bind.annotation.XmlTransient;
    
    @XmlAccessorType(XmlAccessType.FIELD)
    @XmlRootElement(name="cham")
    public class SystemConfig implements Serializable {
    
    	private static final long serialVersionUID = -7667130896271777648L;
    	
    	@XmlAttribute(name="formatversion")
    	private String formatVersion;
    	
    	@XmlElement(name="servers")
    	private Servers servers;
    
    	@XmlTransient
    	public String getFormatVersion() {
    		return formatVersion;
    	}
    
    	public void setFormatVersion(String formatVersion) {
    		this.formatVersion = formatVersion;
    	}
    
    	@XmlTransient
    	public Servers getServers() {
    		return servers;
    	}
    
    	public void setServers(Servers servers) {
    		this.servers = servers;
    	}
    
    	@Override
    	public String toString() {
    		return "SystemConfig {formatVersion=" + formatVersion + ", servers=" + servers + "}";
    	}
    }

    至此,注解部分已经完成。

    5. XML文件的位置

    一般来讲,无论C/C++还是java,都会将配置文件放置在工程的某个目录之下。由于作者开发中使用到了tomcat容器,根据习惯,故将配置文件放置在tomacat下的/conf/目录下

    java提供 getProperty 方法获取/conf/上层路径,即我们可以通过 String configPath = System.getProperty("catalina.base"); 方式来获取到/conf/的路径,其中catalina.base即为/conf/上层路径,读者可以查看相关tomcat文档中的定义

    6. 分隔符的讲解

    该部分是作者在开发过程中碰到的一个小陷阱,特拿出来和大家分享;作者在获取到路径后却始终不能读取文件,后来发现是缺少分隔符

    我们可以通过如下代码获取/conf/路径并添加分隔符

    if(!this.configPath.endsWith(File.separator)) {
    			this.configPath = this.configPath + File.separatorChar + "conf" + File.separatorChar;
    		}else {
    			this.configPath = this.configPath + "conf" + File.separatorChar;
    		}

    如果我们再创建一个 configFile变量来存储cham.xml文件,则configFile=configPath+"cham.xml";

    7.java中读取xml注解的方式

    这段代码比较固定,读者可以再网上任意搜到

    package com.china.domain.comm.basicread;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.InputStream;
    
    import javax.xml.bind.JAXBContext;
    
    import org.xml.sax.InputSource;
    
    import com.china.domain.config.SystemConfig;
    
    import javax.xml.bind.Unmarshaller;
    
    public class XmlReaders {
    
    	private String configPath;
    	
    	private String configFile;
    	
    	private SystemConfig config;
    
    	public XmlReaders(String configPath) {
    		super();
    		this.configPath = configPath;
    		initConfigPath();
    		initSystemConfig();
    	}
    	
    	private void initConfigPath() {
    		if(null == this.configPath) {
    			System.out.println("configPath is null");
    			return;
    		}
    		
    		if(!this.configPath.endsWith(File.separator)) {
    			this.configPath = this.configPath + File.separatorChar + "conf" + File.separatorChar;
    		}else {
    			this.configPath = this.configPath + "conf" + File.separatorChar;
    		}
    		
    		this.configFile = this.configPath + "cham.xml";
    	}
    	
    	private void initSystemConfig() {
    		if(null == this.configFile) {
    			System.out.println("configFile is null");
    			return;
    		}
    		try {
    		    JAXBContext context = JAXBContext.newInstance(SystemConfig.class);//首先创建SystemConfig.java的模型
    		    Unmarshaller umar = context.createUnmarshaller();
    		    File file = new File(this.configFile);
    		    InputStream inputStream = new FileInputStream(file);//通过输入流读取配置文件
    		    InputSource source = new InputSource(inputStream);
    		    source.setEncoding("UTF-8");//设置读取字节的方式
    		    this.config = (SystemConfig)umar.unmarshal(inputStream);
    		}catch(Exception e) {
    			System.out.println("Exceptions : " + e.toString());
    		}
    	}
    
    	public String getConfigPath() {
    		return configPath;
    	}
    
    	public void setConfigPath(String configPath) {
    		this.configPath = configPath;
    	}
    
    	public String getConfigFile() {
    		return configFile;
    	}
    
    	public void setConfigFile(String configFile) {
    		this.configFile = configFile;
    	}
    
    	public SystemConfig getConfig() {
    		return config;
    	}
    
    	public void setConfig(SystemConfig config) {
    		this.config = config;
    	}
    }

    只要调用XmlReaders.java这个类的构造函数,则可以成功的将配置文件读取到SystemConfig.java类中

    8.结果展示

    SystemConfig = SystemConfig {formatVersion=1.14, servers= [centers=[Center [id=1, name=center1, serverPoint= [iphost=127.0.0.1, port=8443, byteSequence=BigEndian], back= [iphost=10.10.10.1, port=8080, byteSequence=BigEndian], argumentRef=ccsArg]]]}
    展开全文
  • spring中的注解xml配置文件中配置对应 需要导入的jar spring-context spring-context-support spring-test commons-logging bean xml文件中的配置 id:对象名字唯一,不能使用特殊字符 name:对象名字 class:类的...

    spring中的注解和xml配置文件中配置对应

    需要导入的jar

    spring-context
    spring-context-support
    spring-test
    commons-logging

    bean

    xml文件中的配置

    id:对象名字唯一,不能使用特殊字符
    name:对象名字
    class:类的全限定名 包名.类名
    init-method:初始化方法
    destroy-method:销毁对象之前执行的方法
    scope:作用域范围

    • prototype:多例

      • 创建一次是一个新的对象
    • singleton:单例(懒汉式 饿汉式)

      • 不管如何创建,只能是一个对象

    lazy-init:是否延迟加载当前对象
    只在单例模式下有效(多例模式下每次都需要调用无参构造对象,所以无效)

    • 1.false 立即加载 加载当前spring配置文件时就创建对象
    • 2.true 延迟加载 当第一次调用对象时加载

    ref:引入参照对象

    property 无参构造

    name:对象中属性的名字
    value:赋的值

    constructor-arg有参构造

    name注入:属性名
    type注入:属性名的类型
    index注入:类中第一个属性名为下标为 0

    <bean id="provincesId"
              name="provinces"
              class="com.lanou.pojo.Provinces"
              init-method="init"
              destroy-method="destroy"
              scope="singleton"
              lazy-init="true"
        >
            <!--利用setter方法给对应的属性赋值-->
            <property name="id" value="1"></property>
            <property name="province" value="北京市"></property>
            <property name="provinceid" value="110000"></property>
        </bean>
    
    	<bean id="user" class="com.lanou.pojo.User" scope="singleton" lazy-init="true">
            <constructor-arg name="id" value="123" type="int"></constructor-arg>
            <constructor-arg name="username" value="说爱你" type="java.lang.String"></constructor-arg>
            <constructor-arg name="password" value="love" type="java.lang.String"></constructor-arg>
            <!--<constructor-arg index="0" value="121"></constructor-arg>-->
            <!--<constructor-arg index="1" value="我爱你"></constructor-arg>-->
            <!--<constructor-arg index="2" value="sss"></constructor-arg>-->
        </bean>
    
    

    复杂数据类型配置

    
        <bean id="testCollection" class="com.lanou.pojo.TestCollection">
            <!--对象类型 ref引入参照对象-->
            <property name="user" ref="user"></property>
            <!--数组-->
            <property name="array">
                <list>
                    <value>郑州</value>
                    <value>123</value>
                    <value>0.12</value>
                </list>
            </property>
            <!--集合类型list-->
            <property name="list">
                <list>
                    <value>郑州</value>
                    <value>洛阳</value>
                    <value>开封</value>
                </list>
            </property>
            <!--集合类型map-->
            <property name="map">
                <map>
                    <entry key="area" value="河南"></entry>
                    <entry key="fruit"  value="芒果"></entry>
                    <entry key="user" value-ref="user"></entry>
                </map>
            </property>
            <!--Properties类型赋值 key=value-->
            <property name="properties">
                <props>
                    <prop key="driver">com.mysql.jdbc.Driver</prop>
                    <prop key="url">jdbc:mysql://localhost/mybatis</prop>
                    <prop key="username">root</prop>
                    <prop key="password">123456</prop>
                </props>
            </property>
        </bean>
    

    bean的注解

    开启注解

     		<!--可省略不写 开启spring注解功能-->
           <context:annotation-config></context:annotation-config>
           <!--定义注解扫描的包-->
           <context:component-scan base-package="com.lanou"></context:component-scan>
    

    配置类

    @Component 普通的javabean pojo包,util包
    @Scope 单例多例模式值()
    @Lazy延迟加载

    配置属性赋值

    @Value(value = “123”)

    配置方法

    @PostConstruct 初始化注解
    @PreDestroy 销毁对象之前执行的方法

    @Component(value = "user")
    @Scope
    public class User {
        @Value(value = "123")
        private int id;
        @Value("张三")
        private String username;
        @Value("123456")
        private String password;
    

    层与层之间调用

    xml配置

     <bean id="provincesService" class="com.lanou.service.serviceImpl.ProvincesServiceImpl"></bean>
    
        <bean id="provincesServlet" class="com.lanou.servlet.ProvincesServlet">
            <property name="id" value="100"></property>
            <property name="provincesService" ref="provincesService"></property>
        </bean>
    

    注解

    控制层上注解类上面使用

    @Controller(value = “userController”)

    业务层类上使用的注解

    @Service(“userService”)

    属性上使用的注解

    @Autowired //既可以通过类型,也可以通过名称注入
    @Qualifier(value = “userDao2”)// 两个注解联合使用时,强制指定通过名称注入
    @Resource(name = “userDao2”)

    持久层类使用的注解

    @Repository(“userDao”)

    @RunWith(SpringJUnit4ClassRunner.class) 创建sprng容器
    @ContextConfiguration(“classpath:applicationContext.xml”) 指定配置文件位置

    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    

    aop 面向切面编程

    xml文件中的配置

    aop:config 定义切入点
    aop:pointcut 切入点

    • id : 名称

    • expression : 表达式 找到包、类、方法
      execution(* com.lanou.service..(…))
      第一个* 方法的返回值类型
      com.lanou.service 包名
      第二个* 类名
      第三个* 方法名
      (…) 任意参数
      aop:aspect 定义关联的切面
      aop:before 前置通知

      • method:切面中的前置方法
      • pointcut-ref:切入点

    aop:after 后置通知
    aop:after-returning :后置通知 如果异常不返回值
    aop:after-throwing :后置通知 异常返回
    aop:around :环绕通知

    <!--定义切面信息-->
    <bean id="logAdvice" class="com.lanou.utils.LogAdvice2"></bean>
        <!--定义切入点-->
        <aop:config>
            <aop:pointcut id="pc" expression="execution(* com.lanou.service.*.*(..))"/>
            <!--定义关联的切面-->
            <aop:aspect ref="logAdvice">
                <aop:before method="before" pointcut-ref="pc"></aop:before>
                <aop:after method="after" pointcut-ref="pc"></aop:after>
                <aop:after-returning method="afterReturning" pointcut-ref="pc"></aop:after-returning>
                <aop:after-throwing method="afterException" pointcut-ref="pc"></aop:after-throwing>
                <aop:around method="around" pointcut-ref="pc"/>
            </aop:aspect>
        </aop:config>
    

    注解中的配置

    导入aop需要的jar包

    <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-aspects</artifactId>
          <version>5.1.14.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/aopalliance/aopalliance -->
        <dependency>
          <groupId>aopalliance</groupId>
          <artifactId>aopalliance</artifactId>
          <version>1.0</version>
        </dependency>
    

    @Aspect:声明当前类是一个切面类
    @Pointcut(“execution(* com.lanou.service..(…))”):切入点
    @Before(“LogAdvice.pc()”): 前置通知方法
    @After(“execution(* com.lanou.service..(…))”):后置通知方法 不管是否异常都返回
    @AfterReturning(“execution(* com.lanou.service..(…))”):后置通知 如果异常不返回值
    @AfterThrowing(“execution(* com.lanou.service..(…))”):后置通知 异常返回

     <!--开启aop注解-->
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
    @Component(value = "logAdvice")
    //声明当前类是一个切面类
    @Aspect
    public class LogAdvice {
        @Pointcut("execution(* com.lanou.service.*.*(..))")
        public void pc(){
    
        }
        @Before("LogAdvice.pc()")
        public void before(){
            System.out.println("--前置通知----");
        }
        /*
        切面方法
        后置通知方法 不管是否异常都返回
         */
        @After("execution(* com.lanou.service.*.*(..))")
        public void after(){
            System.out.println("--后置通知----");
        }
        /*
        后置通知 如果异常不返回值
         */
        @AfterReturning("execution(* com.lanou.service.*.*(..))")
        public void afterReturning(){
            System.out.println("---后置通知--无异常-");
        }
        /*
        后置通知 异常返回
         */
        @AfterThrowing("execution(* com.lanou.service.*.*(..))")
        public void afterException(){
            System.out.println("--后置通知--异常通知--");
        }
        /*
        环绕通知
         */
        @Around("execution(* com.lanou.service.*.*(..))")
        public Object around(ProceedingJoinPoint point) throws Throwable {
            System.out.println("环绕通知--前置通知");
            Object object = point.proceed();//继续调用目标方法
            System.out.println("环绕通知--后置通知");
            return object;
        }
    }
    

    事务的注解

    导包

    <!--导入事务的jar-->
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-tx</artifactId>
          <version>5.1.14.RELEASE</version>
        </dependency>
    

    在xml中的配置

     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
            <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mybaits"></property>
            <property name="user" value="root"></property>
            <property name="password" value="123456"></property>
        </bean>
    
        <!--事务切面bean-->
      <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"></property>
      </bean>
           <!--配置事务通知-->
           <tx:advice id="txAdvice" transaction-manager="transactionManager">
               <tx:attributes>
                   <tx:method name="*" propagation="REQUIRED" rollback-for=""/>
               </tx:attributes>
           </tx:advice>
           <!--配置事务切面-->
           <aop:config>
               <!--配置切入点-->
               <aop:pointcut id="pt" expression="execution(* com..service..*.*(..))"></aop:pointcut>
               <!--配置切入点和切面关联-->
               <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"></aop:advisor>
           </aop:config>
    

    在类上使用

    @Transactional(
            propagation = Propagation.REQUIRED,
            isolation = Isolation.READ_COMMITTED,
            timeout = 600
    )
    
    展开全文
  • @ConfigurationProperties和@Value两个注解能从配置文件中获取数据,且只能从全局配置文件中获取, 如果有些配置数据需要他离出来,比如数据库连接信息放 jdbc.properties 里,可使用注解@PropertiySource读取外部...

    一、注解@PropertiySource读取外部属性文件

    @ConfigurationProperties和@Value两个注解能从配置文件中获取数据,且只能从全局配置文件中获取,

    如果有些配置数据需要他离出来,比如数据库连接信息放 jdbc.properties 里,可使用注解@PropertiySource读取外部属性文件。

     

    1、在前面的springbootdemo1项目中 中定义 user.properties 外部属性文件

          application.yml 全局配置文件为空,  user.properties 外部属性文件定义User类信息

    #user类
    user.id=2001
    user.username=李四
    user.pazzword=lisi123
    user.birthday=2019/05/08
    user.list=aaa,bbb,ccc
    user.map.key1=value1
    user.map.key2=value2
    user.address.id=2001
    user.address.detail=浙江杭州

    2、User 类 通过注解@PropertiySource读取 user.properties 外部属性文件

    @Component
    @PropertySource("classpath:user.properties")
    public class User implements Serializable {
       ...属性信息没变
    }

    3、运行测试类即可读取到数据

      

     

    二、注解@ImportResource引入自定义spring的xml配置文件和配置类

    1、注解@ImportResource引入自定义spring的配置xml文件(不推荐
    Spring的配置文件是可以有很多个的,我们在web.xml中如下配置就可以引入它们:

        
    SprongBoot默认已经配置好了Spring,它的内部相当于已经有一个配置文件,那个我们可以通过注解@ImportResource引入新添加配置文件

    public class Address {
        private long id;
        private String detail;
    
    }

      注意: Address类 注解@Component 与下面测试不要重复使用。

    1)创建一个新的spring配置文件(简单注入一个bean):

    <?xml version="1.0" encoding="UTF-8"?>
    <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="address" class="cn.jq.springbootdemo1.springbootdemo1.model.Address"></bean>
    </beans>


    2)程序主类入口上添加注解@ImportResource

    @SpringBootApplication
    @ImportResource("classpath:spring.xml")
    public class Springbootdemo1Application {
    
        public static void main(String[] args) {
            SpringApplication.run(Springbootdemo1Application.class, args);
        }
    
    }

    3)运行测试类(读到对象信息即OK):

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class Springbootdemo1ApplicationTests {
    
        @Autowired
        private User user;
    
        @Autowired
        private Address address;
    
        @Test
        public void contextLoads() {
            System.out.println("user===" + user);
            System.out.println("address===" + address);
        }
    
    }

       

    2、SpirngBoot的配置类(推荐使用)
         SpringBoot 推荐尽可能全部用注解完成配置,所有它使用了一种配置类”来替代上面的spring的xml配置文件。


    1)定义一个类做为配置类,用这个配置类代替spring.xml,所有他们之间存在一个一一对应的关系
    删除上面的spring的xml配置文件和程序主类入口上添加的注解@ImportResource,创建配置类

    @Configuration
    public class AddressConfig {
    
        @Bean
        public Address address(){
            return new Address();
        }
    }

    2)同样运行测试类,若读到对象信息即OK:结果通上面相同

     

    ends ~

     

    展开全文
  • 在SpringMvc.xml中加上 <context:property-placeholder location="classpath:*....然后代码中以注解形式获取配置文件中的配置 @Value("${uploadFolder}") private String UPLOAD_FOLDER; *.properties中 #本地存...

    SpringMvc.xml中加上

    <context:property-placeholder location="classpath:*.properties"/>
    也就是添加配置文件的路径
    

    然后代码中以注解形式获取配置文件中的配置

    @Value("${uploadFolder}")
    private String UPLOAD_FOLDER;
    

    *.properties中

    #本地存放路径
    uploadFolder=E:/img/
    
    展开全文
  • 在上面引出事务的代码基础上,只需要修改xml配置文件 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2...
  • springMvc的项目中,通过注解@Value获取properties配置文件中的配置,使用该注解必须引入的包: spring-beans-4.1.4.RELEASE.jar 下面是需要在spring的配置文件中配置的内容 beans xmlns=...
  • 在pom.xml中配置父工程和子工程的依赖,以及使用注解完成一个简单的web项目 1.在前一篇文章说道了Spring的核心特点是使用Springboot的话我们直接创建一个Java项目即可,最后打包成jar包,那么我们先创建一个Java项目...
  •  1、用法示例: 在springMVC.xml配置文件中添加标签 (推荐用这个,这个用的比较多,也比较简洁) &lt;context:property-placeholder location="classpath:salesman.properties"/&gt;  加载...
  • 以前,没有@Value注解的时候,想要在类中获取配置文件的值,我一般是新增一个Param.java类,并把Param类配置在spring的xml文件中,在这个xml文件中通过${xx}给Param的属性注入值,那么在其他类中要使用properties...
  • 我们有时候因为开发和部署的环境的不同 一些定义的常量或者对象属性也需要更改 这样就很麻烦 在springboot 如火如荼的今天,我们是否也可以将那些因为不同环境而需要不同修改的常量或者对象也放在配置文件中呢 ...
  • task.properties配置文件:corn=0/1 * * * * ?...name=job读取方式:1加载配置文件:@PropertySource(value = "classpath:task.properties") 读取: 注册bean: @Bean public static PropertySourcesPlaceho
  • springboot xml文件读取yml文件配置信息

    千次阅读 2019-09-29 02:39:13
    springboot xml文件动态读取yml文件配置信息,在不同环境下读取对应配置文件的参数信息 1.借助springboot springProperty的标签实现 2.yml文件配置参数 graylog: url: XXXXX3.logback.xml 文件读取参数 <...
  • @value从配置文件properties中读取配置值 @Controller @RequestMapping("/value") public class ValuePropertyController extends ApplicationController{ @Value("#{configProperties['jdbc.jdbcUrl']}")
  • 第二步: 将version 标签的值读取配置文件中 这里使用 @@ 而不是 ${} 是因为spring boot 无法识别配置文件中的 ${} 符号会导致报错。 第三步: 如果是在spring boot 默认配置文件中配置...
  • springMvc的项目中,通过注解@Value获取properties配置文件中的配置,使用该注解必须引入的包: spring-beans-4.1.4.RELEASE.jar 下面是需要在spring的配置文件中配置的内容 beans xmlns=...
  • 但是光使用注解是不能完全取代所有的配置问价的,使用SpringMVC主要有三种配置文件,pom.xml、web.xml、springmvc.xml三种,下面我们分别说一下三种配置文件主要配置哪些内容。 1、pom.xml文件: pom.xml文件严格来...
  • 1.当springboot项目里同时有application.yml配置文件和application.properties文件时,用@Component和@ConfigurationProperties(prefix = “person”)注解时,究竟读取哪一个? 答: 正常的情况是先加载yml,接下来...
  • 在iteye上看到个问题spring事务的注解...通过设置注解@Transactional(readOnly=false)和xml配置里相同或相反的readOnly属性,然后向数据库插入数据,通过执行的来结果判定优先级。 测试结果:有注解时使用注解里的
  • 在一个稍大的项目,通常会有上百个组件,如果这些组件采用XML的bean定义来配置,显然会增加配置文件的体积,查找及维护起来也不太方便。Spring建议最好使用注解+组件自动扫描机制的方式代替复杂的xml配置文件,来...
  • 注解读取properties文件中内容:springMvc获取properties文件的注解方式: 需要的jar包:spring-beans-4.1.4.RELEASE.jar 1.首先需要在application.xml中注入:<!--配置注解配置文件读取-->...
  • springMvc的项目中,通过注解@Value获取properties配置文件中的配置,使用该注解必须引入的包: spring-beans-4.1.4.RELEASE.jar 下面是需要在spring的配置文件中配置的内容 <?xml version="1.0" encoding=...
  • Spring 通过注解获取*.porperties文件内容,除了xml配置外,还可以通过@value方式来获取。 @value是需要spring注解扫描的,所以要将spring注解扫描配置中加上实体类的包名路径,实体类也应添加@Component@...
  • springboot读取xml配置文件

    千次阅读 2020-06-23 21:39:20
    xml文件内容 在src/main/resources下面添加《operator-config.xml文件文件内容如下: <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <operator-config group="business"> <operator...
  • XML 配置方式进一步降低了耦合,是的应用更容易拓展,即使对配置文件进一步修改也不需要对工程进行修改和重新编译。 在处理打业务量的时候,使用 XML 配置应该更好一些,因为 XML 更加清晰的表明了各个对象之间的...
  • 使用 @PropertySource 指定配置文件路径,支持 properties 和 XML配置文件,但不支持 yml。 属性赋值 可以用注解 @Value 对属性直接赋值、${}获取配置文件的值、SPEL表达式#{}。 直接赋值:@Value("name jack...
  • 此工具自动生成非注解时Spring整合MyBatis时需要的一些配置文件,对于使用较新版本的spring,可以忽视生成的dao的配置文件,建议采用spring的扫描方式。生成的GeneratorConfigXML修改jdbc驱动位置后可直接用使用...
  • 本质上,三者都是信息的载体,或者说向程序传递信息的方式!那么说道传递,就涉及到主体、客体两方,也就是“谁”要把“什么”传递给“谁”...比如Spring框架注解,@Component,@Controller等等,在bean加载的过程
  • 在主配置文件中配置mapper 在SqlMapConfig.xml中,配置mapper时使用class属性指定dao接口的全限定类名,代码如下:(主要是最后几行发生了变化),配置完成后就可以把resources下的com.cjx.dao.IUserDao.xml文件删掉...
  • 本文是《凯哥陪你学系列-框架学习之spring boot框架学习》spring boot框架学习学前掌握之重要注解(4)-通过注解方式读取外部资源配置文件2。欢迎大家提意见 一:上节思考问题: 1:如果是多个配置文件怎么写...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 77,179
精华内容 30,871
关键字:

xml文件通过注解读取配置文件中内容