如何在context.xml中存储字符串值（context.xml作用）

25-02-27 13

对于如何在context.xml中存储字符串值感兴趣的读者，本文将会是一篇不错的选择，我们将详细介绍context.xml作用，并为您提供关于android–在哪里存储字符串值？在strings.xm

对于如何在context.xml中存储字符串值感兴趣的读者，本文将会是一篇不错的选择，我们将详细介绍context.xml作用，并为您提供关于android – 在哪里存储字符串值？在strings.xml或constants类中？、applicationcontext.xml php xml留言板 xml存储数据的简单例子、applicationContext.xml中和的区别、c# – 如何在使用db context时指定连接字符串的有用信息。

本文目录一览：

如何在context.xml中存储字符串值（context.xml作用）
android – 在哪里存储字符串值？在strings.xml或constants类中？
applicationcontext.xml php xml留言板 xml存储数据的简单例子
applicationContext.xml中和的区别
c# – 如何在使用db context时指定连接字符串

如何在context.xml中存储字符串值（context.xml作用）

我想将连接URL存储在Tomcat应用程序的JNDI绑定中。由于Tomcat
context.xml用于JNDI资源定义，因此我需要弄清楚在中存储String（或用于多个连接的多个字符串）的适当方法context.xml。

我这样做的原因是，我可以为不同的环境定义不同的字符串，然后通过JNDI加载它们。

通常，我看到这样的条目：

<Context ...>    <Resource name="someName" auth="Container"            type="someFullyQualifiedClassName"            description="Some description."/></Context>

真的就这么简单吗：

<Context ...>    <Resource name="myConnectionURL" auth="Container"            type="java.lang.String"            description="A connection URL string."/></Context>

如果是这样， 我实际在哪里存储字符串值？！？！ 如果不正确，那么对我来说合适的存储方式是什么，例如“
amqp:5272//blah.example.com&param1=4”，context.xml这样我就可以像这样查找它：

Context ctx = new InitialContext();String connectionURL = (String)ctx.lookup("myConnectionURL");

提前致谢！

答案1

小编典典

您可以通过将元素嵌套在元素中来配置命名值，这些值将作为Servlet上下文初始化参数对Web应用程序可见。例如，您可以创建一个初始化参数，如下所示：

 <Context>      ...     <Parameter name="companyName" value="My Company, Incorporated"          override="false"/>       ... </Context>   This is equivalent to the inclusion of the following element in the web application deployment descriptor (/WEB-INF/web.xml): <context-param>       <param-name>companyName</param-name>       <param-value>My Company, Incorporated</param-value> </context-param>

您的Java代码如下所示

 ServletContext sc = getServletContext(); String companyName = sc.getInitParameter("companyName");

请参阅参考http://tomcat.apache.org/tomcat-7.0-doc/config/context.html

android – 在哪里存储字符串值？在strings.xml或constants类中？

在android中,我们可以将字符串值存储在strings.xml文件中或存储在某些常量类中作为静态最终变量.在某些情况下,是否有某些原因可以选择一个在另一个上？

解决方法:

简而言之：

代码中使用的值：使用always constants class.Advantage：代码保持集成,您的包可以在其他项目/上下文中使用.你不能用string.xml做到这一点,因为它不随你的包运输.

在UI中显示的值：使用string.xml.优点：您可以使用本地化来显示翻译文本.

当两种选择都可行时,可能会出现某种情况.然后,您必须确定其相关值的存储位置.

applicationcontext.xml php xml留言板 xml存储数据的简单例子

类文件 : _class.xmldb.inc.php

复制代码代码如下:

class xmldb extends DOMDocument{
    var $xmldb;
    public function __construct($xmldbname){
        $this->xmldb=$xmldbname;
        if(!file_exists($this->xmldb)){
            $initxmldb = "";
            $this->loadXML($initxmldb);
            $this->save($this->xmldb);
        }else{
            $this->load($this->xmldb);
        }
    }
    public function insert_message($nickname,$message){
        $messagedom = $this->getElementsByTagName("Message");
        $subnode = $this->createElement("Rows");
        $nicknamenode = $this->createElement("Nickname");
        $nicknamenode -> appendChild($this->createTextNode($nickname));
        $subnode -> appendChild($nicknamenode);
        $contentnode = $this->createElement("Content");
        $contentnode -> appendChild($this->createTextNode($message));
        $subnode -> appendChild($contentnode);
        $timernode = $this->createElement("Timer");
        $timernode -> appendChild($this->createTextNode(time()));
        $subnode -> appendChild($timernode);
        $messagedom->item(0)->appendChild($subnode);
        $this->saveXML();
        $this->save($this->xmldb);
    }
    function get_node_length($nodename){
        $odom = $this->getElementsByTagName($nodename);
        return $odom->length;
    }
    public function get_message_list($start,$rowscount,$pagesize){
        $end = $rowscount > $pagesize ? $start+$pagesize : $rowscount;
        $k = 0;
        for($i = $start; $i             $rowslist[$k]["Nickname"] = $this->getElementsByTagName("Nickname")->item($i)->nodeValue;
            $rowslist[$k]["Content"] = $this->getElementsByTagName("Content")->item($i)->nodeValue;
            $rowslist[$k]["Timer"] = $this->getElementsByTagName("Timer")->item($i)->nodeValue;
            $k++;
        }
        return $rowslist;
    }
    public static function splitpage($pageall,$page=1,$urled=null,$strpage = "page",$pageaverage = 10){
            $pageaverage -= 1;
            $page = intval($page >=1 ? $page : 1 );
            $page = $page > $pageall ? $pageall : $page;
            $startpage = $page - $pageaverage > 0 ? $page - ceil(($pageaverage / 2)):1;
            $startpage = ($page + ceil($pageaverage/2) > $pageall)?$pageall-$pageaverage:$startpage;
            $startpage = $startpage > 0 ? $startpage : 1;
            $stoppage = $startpage+$pageaverage >$pageall?$pageall:$startpage+$pageaverage;
            if(empty($urlfile)){ $urlfile=$_SERVER["PHP_SELF"]; }
            if(!strrpos($urlfile,''?'')) $urled .= ''?'';
            foreach($_GET as $k => $v)
            {
                $urled = ($k$strpage) ? $urled.$k.''=''.urlencode($v).''&'' : $urled;
            }
            if ($page>1){
                $mess ="首页 ";
                $mess .="上一页 ";
            }else{
                $mess ="首页 ";
                $mess .="上一页 ";
            }
            if($page > 9){
                $startpage = $page - 9;
            }
            $stoppage = $startpage + 9 >= $pageall ? $pageall : $startpage + 9;
            for($i= $startpage; $i            {
                if($i                    $mess .= "".$i." ";
                else
                    $mess .= "".$i." ";
            }
            if ($page                 $mess .=" 下一页";
                $mess .=" 尾页";
            }else{
                $mess .=" 下一页";
                $mess .=" 尾页";
            }
        return $mess;
    }
}
?>

调用文件 : index.php

复制代码代码如下:

require("_class.xmldb.inc.php");
$xmldb = new xmldb("./my_xmldb.xml");
if(isset($_POST["btnform1"])){
    $xmldb -> insert_message($_POST["nickname"],$_POST["content"]);
}
$pagesize        = 3;
$page            = !empty($_GET[''page'']) ? intval($_GET[''page'']) : 1;
$rowscount        = $xmldb -> get_node_length("Rows");
$pagecount        = ceil($rowscount/$pagesize);
$start            = ($page-1)*$pagesize > $rowscount ? $rowscount : ($page-1)*$pagesize;
$rowslist = $xmldb -> get_message_list($start,$rowscount,$pagesize);
?>

(".date("Y-m-d H:i",$value["Timer"]).")";
echo "

".$value["Content"]."

";
            }
        }
    ?>

=$xmldb -> splitpage($pagecount,$page,'''',''page'',$pagesize)?>

applicationContext.xml中<context:annotation-config> 和 <context:component-scan>的区别

applicationContext.xml中和的区别

Difference between <context:annotation-config> vs <context:component-scan>

<context:annotation-config>是用于激活那些已经在spring容器里注册过的bean（无论是通过xml的方式还是通过package sanning的方式）上面的注解。

<context:component-scan>除了具有<context:annotation-config>的功能之外，<context:component-scan>还可以在指定的package下扫描以及注册javabean。

下面我们通过例子来详细查看他们的区别，

有三个class A,B,C,并且B,C的对象被注入到A中.

package com.xxx;
public class B {
  public B() {
    System.out.println("creating bean B: " + this);
  }
}

package com.xxx;
public class C {
  public C() {
    System.out.println("creating bean C: " + this);
  }
}

package com.yyy;
import com.xxx.B;
import com.xxx.C;
public class A { 
  private B bbb;
  private C ccc;
  public A() {
    System.out.println("creating bean A: " + this);
  }
  public void setBbb(B bbb) {
    System.out.println("setting A.bbb with " + bbb);
    this.bbb = bbb;
  }
  public void setCcc(C ccc) {
    System.out.println("setting A.ccc with " + ccc);
    this.ccc = ccc; 
  }
}

在applicationContext.xml中加入下面的配置 :

<bean id="bBean"class="com.xxx.B"/><bean id="cBean"class="com.xxx.C"/><bean id="aBean"class="com.yyy.A"><property name="bbb" ref="bBean"/><property name="ccc" ref="cBean"/></bean>

加载applicationContext.xml配置文件，将得到下面的结果:

creating bean B: com.xxx.B@c2ff5 creating bean C: com.xxx.C@1e8a1f6 creating bean A: com.yyy.A@1e152c5 setting A.bbb with com.xxx.B@c2ff5 setting A.ccc with com.xxx.C@1e8a1f6

OK,这个结果没什么好说的，就是完全通过xml的方式，不过太过时了，下面通过注解的方式来简化我们的xml配置文件

首先，我们使用autowire的方式将对象bbb和ccc注入到A中：

package com.yyy;
import org.springframework.beans.factory.annotation.Autowired;
import com.xxx.B;
import com.xxx.C;
public class A { 
  private B bbb;
  private C ccc;
  public A() {
    System.out.println("creating bean A: " + this);
  }
  @Autowired
  public void setBbb(B bbb) {
    System.out.println("setting A.bbb with " + bbb);
    this.bbb = bbb;
  }
  @Autowired
  public void setCcc(C ccc) {
    System.out.println("setting A.ccc with " + ccc);
    this.ccc = ccc;
  }
}

然后，我们就可以从applicationContext.xml中移除下面的配置

<property name="bbb" ref="bBean"/><property name="ccc" ref="cBean"/>

移除之后，我们的applicationContext.xml配置文件就简化为下面的样子了

<bean id="bBean"class="com.xxx.B"/><bean id="cBean"class="com.xxx.C"/><bean id="aBean"class="com.yyy.A"/>

当我们加载applicationContext.xml配置文件之后，将得到下面的结果：

creating bean B: com.xxx.B@5e5a50 creating bean C: com.xxx.C@54a328 creating bean A: com.yyy.A@a3d4cf

ottom: 1em; border: 0px; vertical-align: baseline; clear: both; font-family: Arial,结果是错误的的，究竟是因为什么呢？为什么我们的属性没有被注入进去呢？

是因为注解本身并不能够做任何事情，它们只是最基本的组成部分，我们需要能够处理这些注解的处理工具来处理这些注解

这就是<context:annotation-config>所做的事情

我们将applicationContext.xml配置文件作如下修改：

<context:annotation-config /><bean id="bBean"class="com.xxx.B"/><bean id="cBean"class="com.xxx.C"/><bean id="aBean"class="com.yyy.A"/>

creating bean B: com.xxx.B@15663a2 creating bean C: com.xxx.C@cd5f8b creating bean A: com.yyy.A@157aa53 setting A.bbb with com.xxx.B@15663a2 setting A.ccc with com.xxx.C@cd5f8b

ottom: 1em; border: 0px; vertical-align: baseline; clear: both; font-family: Arial,结果正确了

但是如果我们将代码作如下修改：

package com.xxx;
import org.springframework.stereotype.Component;
@Component
public class B {
  public B() {
    System.out.println("creating bean B: " + this);
  }
}

package com.xxx;
import org.springframework.stereotype.Component;
@Component
public class C {
  public C() {
    System.out.println("creating bean C: " + this);
  }
}

package com.yyy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.xxx.B;
import com.xxx.C;
@Component
public class A { 
  private B bbb;
  private C ccc;
  public A() {
    System.out.println("creating bean A: " + this);
  }
  @Autowired
  public void setBbb(B bbb) {
    System.out.println("setting A.bbb with " + bbb);
    this.bbb = bbb;
  }
  @Autowired
  public void setCcc(C ccc) {
    System.out.println("setting A.ccc with " + ccc);
    this.ccc = ccc;
  }
}

applicationContext.xml配置文件修改为：

<context:annotation-config />

当我们加载applicationContext.xml配置文件之后，却没有任何输出，这是为什么呢？

那是因为<context:annotation-config />仅能够在已经在已经注册过的bean上面起作用。对于没有在spring容器中注册的bean，它并不能执行任何操作。

但是不用担心，<context:component-scan>除了具有<context:annotation-config />的功能之外，还具有自动将带有@component,@service,@Repository等注解的对象注册到spring容器中的功能。

<context:component-scan base-package="com.xxx"/>

当我们加载applicationContext.xml的时候，会得到下面的结果：

creating bean B: com.xxx.B@1be0f0a creating bean C: com.xxx.C@80d1ff

这是什么原因呢？

是因为我们仅仅扫描了com.xxx包及其子包的类，而class A是在com.yyy包下，所以就扫描不到了

下面我们在applicationContext.xml中把com.yyy也加入进来：

<context:component-scan basepackage="com.xxx,com.yyy"/><context:component-scan base-package="com.xxx"/>

然后加载applicationContext.xml就会得到下面的结果：

creating bean B: com.xxx.B@cd5f8b creating bean C: com.xxx.C@15ac3c9 creating bean A: com.yyy.A@ec4a87 setting A.bbb with com.xxx.B@cd5f8b setting A.ccc with com.xxx.C@15ac3c9

哇，结果正确啦！

回头看下我们的applicationContext.xml文件，已经简化为：

/><context:component-scan base-package="com.xxx"/>

了。

那如果我们在applicationContext.xml手动加上下面的配置，也就是说既在applicationContext.xml中手动的注册了A的实例对象，同时，通过component-scan去扫描并注册B,C的对象

<context:component-scan base-package="com.xxx"/><bean id="aBean"class="com.yyy.A"/>

结果仍是正确的:

creating bean B: com.xxx.B@157aa53 creating bean C: com.xxx.C@ec4a87 creating bean A: com.yyy.A@1d64c37 setting A.bbb with com.xxx.B@157aa53 setting A.ccc with com.xxx.C@ec4a87

虽然class A并不是通过扫描的方式注册到容器中的，但是<context:component-scan>所产生的的处理那些注解的处理器工具，会处理所有绑定到容器上面的bean，不管是通过xml手动注册的还是通过scanning扫描注册的。

那么，如果我们通过下面的方式呢？我们既配置了<context:annotation-config />，又配置了<context:component-scan base-package="com.xxx" />，它们都具有处理在容器中注册的bean里面的注解的功能。会不会出现重复注入的情况呢？

<context:annotation-config /><context:component-scan base-package="com.xxx"/><bean id="aBean"class="com.yyy.A"/>

不用担心，不会出现的：

因为<context:annotation-config />和<context:component-scan>同时存在的时候，前者会被忽略。也就是那些@autowire，@resource等注入注解只会被注入一次

哪怕是你手动的注册了多个处理器，spring仍然只会处理一次：

<context:annotation-config />
<context:component-scan base-package="com.xxx" />
<bean id="aBean"/>
<bean id="bla"/>
<bean id="bla1"/>
<bean id="bla2"/>
<bean id="bla3"/>

结果仍是正确的：

creating bean B: com.xxx.B@157aa53 creating bean C: com.xxx.C@ec4a87 creating bean A: com.yyy.A@25d2b2 setting A.bbb with com.xxx.B@157aa53 setting A.ccc with com.xxx.C@ec4a87

c# – 如何在使用db context时指定连接字符串

我正在使用EF的存储库模式,并遇到了一个问题,我无法弄清楚如何通过变量设置DbContext的连接字符串.目前我的构造函数是无参数的(它必须符合他的模式),即

IUnitOfWork uow = new UnitOfWork<EMDataContext>();
DeviceService deviceService = new DeviceService(uow);
var what = deviceService.GetAllDevices();


public UnitOfWork()
{
    _ctx = new TContext();
    _repositories = new Dictionary<Type,object>();
    _disposed = false;
}

EMDataContext用于在其构造函数中获取一个字符串来定义ConnectionString但是不能再这样做了,那么如何以这种方式实际告诉EMDataContext要连接的内容呢？

解决方法

您的问题可以重写为“如何将参数传递给具有new()约束的泛型类型构造函数”.

从MSDN开始：

The new constraint specifies that any type argument in a generic class
declaration must have a public parameterless constructor.

由于裸实体框架上下文不包含无参数构造函数,因此我假设您的EMDataContext是从中派生的自定义上下文：

public class EMDataContext : DbContext
{
      // parameterless ctor,since you're using new() in UnitOfWork<TContext>
      public EMDataContext() : base(???)
      {
      }

      public EMDataContext(string connectionString) : base(connectionString)
      {
      }
}

现在,我认为您的EMDataContext无法使用无参数构造函数,因此也无法使用new()约束,尤其是当您说您确实要传递连接字符串参数时.

尝试更改UnitOfWork以接受其构造函数中已初始化的上下文(常见模式)：

public class UnitOfWork<TContext>
{
    public UnitOfWork(TContext ctx)
    {
        _ctx = ctx;
    }
}

或者(如果您仍想“适应模式”),尝试使用Activator实例化上下文：

public class UnitOfWork<TContext>
{
    public UnitOfWork(string connectionString)
    {
        _ctx = (TContext)Activator.CreateInstance(typeof(TContext),new[] { connectionString });
    }
}

关于如何在context.xml中存储字符串值和context.xml作用的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于android – 在哪里存储字符串值？在strings.xml或constants类中？、applicationcontext.xml php xml留言板 xml存储数据的简单例子、applicationContext.xml中和的区别、c# – 如何在使用db context时指定连接字符串等相关内容，可以在本站寻找。

本文标签：