A. 怎么用STRING给MYBATIS配置文件传值
使用Mybatis自带的注解@Param 即可轻松解决你的问题！
public interface UserMapper(){
public List<User> findByNo(@Param("teacher") String teacher,
@Param("noList") List<String> noList
)
}
B. java 怎么用配置文件给某个string字符串赋值
看你用什么配置文件了，如果用的是.properties文件，那么可以这样使用：
Propertiesp=newProperties();
try{
//读取配置文件pro.properties
p.load(Test.class.getClassLoader().getResourceAsStream("pro.properties"));
//获取配置文件中的相关内容
Stringstr=p.getProperty("YourName");
}catch(IOExceptione){
e.printStackTrace();
}
配置文件pro.properties文件里可以这样写：
YourName=ErGouZi
C. 如何在Spring容器中加载自定义的配置文件
自定义配置文件
配置文件名为：project.properties，内容如下：
[html] view plain
# 是否开启逻辑删除
project_del.filter.on=false
project_domain=
修改Spring配置文件
之前代码：
[html] view plain
<beanidbeanid="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<propertynamepropertyname="locations">
<list>
<value>classpath:dbinfo.properties</value>
</list>
</property>
</bean>
修改后的配置文件
[html] view plain
<beanidbeanid="propertyConfigurer"
class="com.hisun.core.util.">
<propertynamepropertyname="locations">
<list>
<value>classpath:dbinfo.properties</value>
<value>classpath:project.properties</value>
</list>
</property>
</bean>
加入了classpath:project.properties，其为自定义的配置文件
将PropertyPlaceholderConfigurer类修改为自定义类,
PropertyPlaceholderConfigurer类的具体作用可以查资料这块儿不做详细介绍
注意下：这个configurer类获取的是所有properties的属性map,如果希望处理某个properties文件，需要在properties中
做一个命名区别，然后在加载的时候，根据key的前缀，进行获取。
定义类
类的具体内容为下，
[java] view plain
importjava.util.HashMap;
importjava.util.Map;
importjava.util.Properties;
importorg.springframework.beans.BeansException;
importorg.springframework.beans.factory.config.;
importorg.springframework.beans.factory.config.PropertyPlaceholderConfigurer;
publicclass {
privatestatic Map ctxPropertiesMap;
@Override
protectedvoid processProperties( beanFactoryToProcess,
Properties props)throws BeansException {
super.processProperties(beanFactoryToProcess, props);
ctxPropertiesMap =new HashMap();
for(Object key : props.keySet()) {
String keyStr = key.toString();
if(keyStr.startsWith("project_")){
String value = props.getProperty(keyStr);
ctxPropertiesMap.put(keyStr, value);
}
}
}
publicstatic Object getContextProperty(String name) {
returnctxPropertiesMap.get(name);
}
}
定义获取配置文件中值的类SpringPropertiesUtil
类的具体内容如下：
[java] view plain
importorg.springframework.beans.BeansException;
importorg.springframework.context.ApplicationContext;
importorg.springframework.context.ApplicationContextAware;
importorg.springframework.stereotype.Component;
/**
* Spring-PropertiesUtil工具类 -获取属性值
*
*/
@Component
publicclass SpringPropertiesUtil {
publicstatic final String KEY = "propertyConfigurer";
privatestatic ApplicationContext applicationContext;
publicvoid setApplicationContext(ApplicationContext applicationContext)
throwsBeansException {
SpringPropertiesUtil.applicationContext = applicationContext;
}
publicstatic ApplicationContext getApplicationContext() {
returnapplicationContext;
}
/**
* 获取配置文件中的内容
*
* @param keyName
* @return
*/
publicstatic String parseStr(String keyName) {
cp = () applicationContext
.getBean(KEY);
returncp.getContextProperty(keyName).toString();
}
/**
* 获取配置文件中的内容
*
* @param keyName
* @return
*/
publicstatic int parseInt(String keyName) {
cp = () applicationContext
.getBean(KEY);
returnInteger.parseInt(cp.getContextProperty(keyName).toString());
}
/**
* 获取配置文件中的内容
*
* @param keyName
* @return
*/
publicstatic double parseDouble(String keyName) {
cp = () applicationContext
.getBean(KEY);
returnDouble.parseDouble(cp.getContextProperty(keyName).toString());
}
}
这样，在项目当中就能够方便快速的获取properties文件中配置的参数
如SpringPropertiesUtil.parseStr(“content”)
D. 二、springboot配置文件
1. 配置文件
Spring Boot使用一个全局的配置文件
application.properties
application.yml
配置文件的作用：修改Spring Boot自动配置的默认值，SpringBoot在底层都给我们自动
配置好。有什么配置项，可以移步官方文档
配置文件一般放在src/main/resources目录或者类路径/confifig下，当然还有很多位置可
以放，它们会有不同优先级，后面会讲到。
YAML （YAML Ain't Markup Language）
简单介绍
<!--绑定配置文件处理器，配置文件进行绑定的时候就会有提示-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<!-- 将应用打包成一个可执行Jar包，直接使用java -jar xxxx的命令来执行 -->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>以前的配置文件：大多是xml
.yml是YAML语言的文件，以数据为中 心，比json、xml等更适合做配置文件
全局配置文件的可以对一些默认配置值进行修改
配置实例
xml：
yml:
2. YAML语法
基本语法
K:(空格)V 标识一对键值对
以空格的缩进来控制层级关系
只要是左对齐的一列数据，都是同一层级的
属性和值也是大小写敏感
实例：
值的写法
普通的值
k: v 字面量直接来写，字符串默认不用添加单引号
" " 双引号 不会转义字符串里面的特殊字符；
<server>
<port>8081</port>
</server>
server:
port: 8081
server:
port: 8081
path: /hello // 冒号后面的空格不要拉下' ' 单引号 会转义字符，特殊字符最终是一个普通的字符串
对象
普通写法：
行内写法
frends:{ lastName: zhang,age: 18 }
Map
示例：
maps: {k1: v1,k2: v2}
数组
普通写法：
pets: // var onj = {pets: ['cat','pig','dog']}
- cat
- pig
- dog
行内写法
pets:[cat, pig, dog]
配置文件获取
将配置文件中的每一个值映射到此组件中
1. Persion
name: "wang \n qian" // 输出：wang 换行 qian
frends:
lastName: zhang
age: 20package com.wrq.boot.bean;
@Component
@ConfigurationProperties(prefix = "persion")
public class Persion {
private String name;
private int age;
private double weight;
private boolean boss;
private Date birth;
private Map<String,Object> maps;
private List<Object> list;
private Dog dog;
此处，这个bean的getter、setter和tostring方法已经省略，千万不能忽略！
}
@ConfifigurationProperties 意思是:我们类里面的属性和配置文件中的属性做绑定
不使用此注解，可以在bean的属性添加@value()注解，如下：
@Component
// @ConfigurationProperties(prefix = "persion")
public class Persion {
@value("${persion.name}") // $()读取配置文件、环境变量中的值
private String name;
@value("#{11*2}") // #{SpEL} 采用表达式
private int age;
@value("true") // 直接赋值
private boolean boos;
}
此处采用@ConfifigurationProperties的方式，@value()和@ConfifigurationProperties的
区别见下方表格。prefifix = "persion" 配置文件中那个下面的属性来一一映射
@Component 如果想要这个注解起作用，必须放到容器里面
2. Dog
package com.wrq.boot.bean;
public class Dog { // 用作Persion中的属性
private String name;
private int age;
此处，这个bean的getter、setter和tostring方法已经省略，千万不能忽略！
}
3. 配置文件
方式一: application.yml
persion:
name: 王大锤
age: 18
weight: 125
boss: false
birth: 2018/5/5
maps: {k1: v1,k2: v2}
list:
- wangli
- wang
dog:
name: xiaogou
age: 2
方式二: application.propertiespersion.name = 王大锤
persion.age = 18
persion.weight = 125
persion.boss = false
persion.birth = 2018/5/5
persion.maps.k1 = v1
persion.maps.k2 = v2
persion.dog.name = xiaogou
persion.dog.age = 15
4. 测试类：BootApplicationTests
package com.wrq.boot;
@RunWith(SpringRunner.class)
@SpringBootTest
public class BootApplicationTests {
@Autowired
Persion persion;
@Test
public void contextLoads() {
System.out.print(persion);
}
}
5. 运行 BootApplicationTests方法
控制台打印：
application.yml的结果：
Persion{name='王大锤', age=18, weight=125.0, boss=false, birth=Sat May
05 00:00:00 CST 2018, maps={k1=v1, k2=v2}, list=[wangli, wang],
dog=Dog{name='xiaogou', age=2}}
application.properties的结果：
Persion{name='��Ǭ', age=18, weight=125.0, boss=false, birth=Sat
May 05 00:00:00 CST 2018, maps={k2=v2, k1=v1}, list=[wangli, wang],
dog=Dog{name='xiaogou', age=15}}
把Bean中的属性和配置文件绑定，通过yml文件和properties都可以做到,但是properties
文件出现乱码。
properties中文读取乱码：File->Settings->File Encodings最底部选utf-8、Tranparent打
上勾
注解比较
@value和@ConfifigurationProperties获取值比较
名词解释:
松散绑定
last-name和lastName都可以获取导致，则代表支持松散绑定
JSR303@Component
@ConfigurationProperties(prefix = "persion") // 如果使用的是@value注入值
时，无法使用校验
@Validated // 添加此注解
public class Persion {
@Email // 配置文件书写的属性必须是邮箱格式，不符合报错！
private String name;
}
复杂类型封装
如果获取配置文件中map的值时,@value是获取不到值的
@value("${persion.maps}") // 由于使用的是@value，无法获取配置文件中的map
private Map<String,Object> maps;
@PropertySource
@PropertySource：加载指定配置文件
@ConfifigurationProperties()默认是从全局配置文件中获取值，也就是
application.properties这个文件中获取值。
如果做的配置很多，全局的配置文件就会特别大，为了方便管理。我会创建不同的配置文
件定向管理不同的配置。
如创建persion.properties文件单独存放persion需要的配置
@PropertySource就是用来导入创建的配置文件
示例：
1. persion.properties
同时把两个全局的配置中关于Persion的配置都注释掉persion.name = 王弟弟
persion.age = 18
persion.weight = 125
persion.boss = false
persion.birth = 2018/5/5
persion.maps.k1 = v1
persion.maps.k2 = v2
persion.dog.name = xiaogou
persion.dog.age = 15
2. Persion
package com.wrq.boot.bean;
@Component
@PropertySource(value = {"classpath:persion.properties"})
@ConfigurationProperties(prefix = "persion")
public class Persion {
private String name;
private int age;
private double weight;
private boolean boss;
private Date birth;
private Map<String,Object> maps;
private List<Object> list;
private Dog dog;
此处，这个bean的getter、setter和tostring方法已经省略，千万不能忽略！
}
这样运行测试类，控制台就可以打印persion.properties中的数据。
通过下面的注解，把类路径下的persion.properties加载进来。并且把persion开头的数
据进行绑定。
@PropertySource(value = {"classpath:persion.properties"})@ConfifigurationProperties(prefifix = "persion")
@ImportResource
@ImportResource：导入Spring的配置文件，让配置文件生效。
示例：
1. com.wrq.boot.service
package com.wrq.boot.service;
/**
* Created by wangqian on 2019/1/12.
*/
public class HelloService {
}
2. resources目录手动建立bean.xml
<?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="helloService" class="com.wrq.boot.service.HelloService">
</bean>
</beans>
3. 测试类
package com.wrq.boot;
@RunWith(SpringRunner.class)
@SpringBootTest
public class BootApplicationTests {
@Autowired
ApplicationContext ioc;@Test
public void testConfig() {
boolean b = ioc.containsBean("helloService");
System.out.print(b);
}
}
试图通过添加一个Spring的配置文件bean.xml来把HelloService注入进去。
运行测试类结果：false
结果表明IoC容器中并不包含HelloService，即：配置文件bean.xml没有生效
解决方式
方式一： 主程序中进行配置@ImportResouece注解
package com.wrq.boot;
@ImportResource(locations = {"classpath:bean.xml"}) // 通过此配置是
bean.xml生效
@SpringBootApplication
public class BootApplication {
public static void main(String[] args) {
//应用启动起来
SpringApplication.run(BootApplication.class, args);
}
}
方法二：通过配置类实现，这种方式也是Spring Boot推荐的
1. com.wrq.boot.confifigpackage com.wrq.boot.config;
/**
* Created by wangqian on 2019/1/12.
*/
@Configuration
public class MyConfig {
// 将方法的返回值添加到容器之中,并且容器中这个组件的id就是方法名
@Bean
public HelloService helloService(){
System.out.print("通过@Bean给容器添加组件了..");
return new HelloService();
}
}
@Confifiguration标注这是一个配置类
通过@Bean注解，将方法的返回值添加到容器之中,并且容器中这个组件的id就是方
法名
2. 把主程序类中@ImportResource()配置注释掉
3. 测试成功，添加了HelloService()组件
3. 配置文件占位符
随机数
RandomValuePropertySource：配置文件中可以使用随机数
${random.value}
${random.int}
${random.long}
${random.uuid}
${random.int(10)}
${random.int[1024,65536]}
属性配置占位符可以在配置文件中引用前面配置过的属性（优先级前面配置过的这里都能用）
${app.name:默认值}来指定找不到属性时的默认值
persion.name = 王弟弟${random.uuid}
persion.age = ${random.int}
persion.dog.name = ${persion.name}_dog
4. Profifile 多环境支持
Profifile是Spring对不同环境提供不同配置功能的支持，可以通过激活、 指定参数等方式
快速切换环境
1. 多Profifile的方式
格式：application-{profifile}.properties/yml
application-dev.properties
application-prod.properties
默认采用application.properties配置文件，如果使用别的，需要激活：
1. application.properties中配置：
# 激活application-dev.properties配置文件
spring.profiles.active=dev
2. application-dev.properties:
server.port=8082
3. 运行BootApplication主程序:
2019-01-12 20:46:09.345 INFO 14404 --- [main]
s.b.c.e.t. : Tomcat started on port(s):
8082 (http)
2. 多文档块的方式
除了上方多Profifile的方式来切换环境，也可以通过YAML多文档块的方式。示例:
application.yml:
server:
port: 8081
spring:
profiles:
active: dev
---
spring:
profiles: dev
server:
port: 8083
---
spring:
profiles: prod
server:
port: 8084
3. 激活指定Profifile
1. application.properties中配置：
# 激活application-dev.properties配置文件
spring.profiles.active=dev
2. application.yml中配置
server:
port: 8081
spring:
profiles:
active: dev
---
spring:
profiles: dev
server:
port: 80833. 启动配置-参数
在IDE中，类似于配置tomcat的地方，按下方配置：
Program arguments:--spring.profiles.active=dev
4. 启动配置-虚拟机
在IDE中，类似于配置tomcat的地方，按下方配置：
VM options:-Dspring-profiles-active=dev
5. 命令行 使用Maven的package命令打包，移动到jar的目录。
java -jar spring-boot-project-config.jar --spring.profiles.active=dev
5. 配置文件优先级
GitHub对应项目：boot-confifig-position
优先级
Spring Boot 启动会扫描以下位置的application.properties或者 application.yml文件作
为Spring boot的默认配置文件
fifile:./confifig/ (项目根目录confifig文件夹下的配置文件)
fifile:./ (项目根目下的配置文件)
classpath:/confifig/ (resources目录confifig文件夹下的配置文件)
classpath:/ (resources目下的配置文件)
以上是按照优先级从高到低的顺序，所有位置的文件都会被加载，高优先级配置内容会覆
盖低优先级配置内容,形成互补配置。
默认配置
我们也可以通过配置spring.confifig.location来改变默认配置。
项目打包后以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新
位置；指定配置文件和默认加载的这些配置文件共同起作用，形成互补配置。
1. Maven->package对项目打包2. 把待使用的配置文件放在本地文件夹中，如：D:/application.properties
3. 命令行执行命令
java -jar boot-config-position-xxxxxx.jar --
spring.config.location=D:/application.properties
这样即使项目上线了，我们也可以通过修改本地的配置文件，使用一行命令即可，极大方
便了运维人员。
6. 外部配置加载顺序
Spring Boot 支持多种外部配置方式
可以从以下位置加载配置，优先级从高到低，高优先级配置覆盖低优先级的，所以配置形
成互补配置。
1. 命令行参数
java -jar boot-config-position-xxxxxx.jar --server.port // 多个配置用空格
隔开
2. 来自java:comp/env的JNDI属性
3. Java系统属性（System.getProperties()）
4. 操作系统环境变量
5. RandomValuePropertySource配置的random.*属性值
6. jar包外部的application-{profifile}.properties或application.yml(带spring.profifile)配
置文件
7. jar包内部的application-{profifile}.properties或application.yml(带spring.profifile)配
置文件
8. jar包外部的application.properties或application.yml(不带spring.profifile)配置文件
9. jar包内部的application.properties或application.yml(不带spring.profifile)配置文件
10. @Confifiguration注解类上的@PropertySource
11. 通过SpringApplication.setDefaultProperties指定的默认属性
注意：从jar包外向jar包内寻找，优先加载profifile最后加载不带profifile，更多参考官方文
档
7. 自动配置原理GitHub对应项目：boot-confifig-autoconfifig
1. 配置文件写什么？
配置文件可配置属性查阅
2. 什么是注解，如何实现一个注解？
关于注解的机制和相关原理可以移步此篇博客
3. 配置原理解析
我们运行Spring Boot应用是从main方法启动，在主程序类上有一个
@SpringBootApplication注解。
@SpringBootApplication是一个复合注解，包括@ComponentScan，和
@SpringBootConfifiguration，@EnableAutoConfifiguration。
@SpringBootConfifiguration继承自@Confifiguration，二者功能也一致，标注当前类
是配置类，并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到
srping容器中，并且实例名就是方法名。
@EnableAutoConfifiguration的作用启动自动的配置，@EnableAutoConfifiguration注
解的意思就是SpringBoot根据你添加的jar包来配置你项目的默认配置，比如根据
spring-boot-starter-web ，来判断你的项目是否需要添加了webmvc和tomcat，就
会自动的帮你配置web项目中所需要的默认配置
@ComponentScan，扫描当前包及其子包下被@Component，@Controller，
@Service，@Repository注解标记的类并纳入到spring容器中进行管理。是以前的co
ntext:component-scan（以前使用在xml中使用的标签，用来扫描包配置的平行支
持）。
@SpringBootApplication注解分析
配置原理视频讲解
4. 自动配置类判断
在配置文件properties中设置：debug=true 来让控制台打印自动配置报告，方便的得知
那些配置类生效。
=========================
AUTO-CONFIGURATION REPORT
=========================Positive matches:
-----------------
matched:
- @ConditionalOnClass found required class
'org.springframework.web.servlet.DispatcherServlet';
@ConditionalOnMissingClass did not find unwanted class
(OnClassCondition)
- @ConditionalOnWebApplication (required) found 'session' scope
(OnWebApplicationCondition)
Negative matches:
-----------------
ActiveMQAutoConfiguration:
Did not match:
- @ConditionalOnClass did not find required classes
'javax.jms.ConnectionFactory',
'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)
E. element里面的string.json是什么
string.json是一个HAP项目主要的配置文件。element里面的string.json所有相关配置信息都配置在该文件下；配置文件采用JSON文件格式，每个配置项由属性和值两部分组成；属性的出现不分先后顺序。
F. 中方法返回值为string类型，mybatis配置文件中怎么配置
一．Mybatis简介 MyBatis由Clinton Begin 在2002 年创建，其后，捐献给了Apache基金会，成立了iBatis 项目。2010 年5 月，将代码库迁至Google Code，并更名为MyBatis。 MyBatis 是一个可以自定义SQL、存储过程和高级映射的持久层框架。
G. 用C#如何读写配置文件
INI文件就是扩展名为"ini"的文件。
其一般形式如下：
[section1] // 配置节
//键名 //键值
keyword1 = valuel
keyword2 = value2
……
[section2]
keyword3 = value3
keyword4 = value4
在Windows系统中，INI文件是很多，最重要的就是"System.ini"、"System32.ini"和"Win.ini"。该文件主要存放用户所做的选择以及系统的各种参数。用户可以通过修改INI文件，来改变应用程序和系统的很多配置。但自从Windows 95的退出，在Windows系统中引入了注册表的概念，INI文件在Windows系统的地位就开始不断下滑，这是因为注册表的独特优点，使应用程序和系统都把许多参数和初始化信息放进了注册表中。以及XML文件的国际标准化给INI文件又一次打击。
但在某些场合，INI文件还拥有其不可替代的地位。比如绿色软件的规定就是不向注册表和系统中填入新东西。对于软件需要储存的信息就需要存入到文件中了。XML虽然兼容性比较好，但对于仅仅保存几个自定义参数而言就显得大材小用了。这是就可以选择使用快速简单的储存方式：INI文件。
本文就来探讨一下C#是如何对INI进行读写操作。
主要思路是调用Win32 API。
1.引入命名空间
usingSystem.Runtime.InteropServices;
2.声明(把一个Win32 API函数转成C#函数)
//声明INI文件的写操作函数 WritePrivateProfileString()
[DllImport("kernel32")]
private static extern longWritePrivateProfileString(string section, string key, string val, stringfilePath);
//声明INI文件的读操作函数 GetPrivateProfileString()
[DllImport("kernel32")]
private static extern intGetPrivateProfileString(string section, string key, string def, StringBuilderretVal, int size, string filePath);
3.函数
public void Writue(string section,string key, string value)
{
// section=配置节，key=键名，value=键值，path=路径
WritePrivateProfileString(section,key, value, sPath);
}
public string ReadValue(stringsection, string key)
{
// 每次从ini中读取多少字节
System.Text.StringBuilder temp =new System.Text.StringBuilder(255);
// section=配置节，key=键名，temp=上面，path=路径
GetPrivateProfileString(section,key, "", temp, 255, sPath);
returntemp.ToString(); //注意类型的转换
}
到此基本功能已经实现了。下面我们将所有的代码重新整合一下：
namespace Library.File
{
public class Ini
{
// 声明INI文件的写操作函数 WritePrivateProfileString()
[System.Runtime.InteropServices.DllImport("kernel32")]
private static extern longWritePrivateProfileString(string section, string key, string val, stringfilePath);
// 声明INI文件的读操作函数 GetPrivateProfileString()
[System.Runtime.InteropServices.DllImport("kernel32")]
private static extern intGetPrivateProfileString(string section, string key, string def,System.Text.StringBuilder retVal, int size, string filePath);
private string sPath = null;
public Ini(string path)
{
this.sPath = path;
}
public void Writue(string section,string key, string value)
{
// section=配置节，key=键名，value=键值，path=路径
WritePrivateProfileString(section,key, value, sPath);
}
public string ReadValue(stringsection, string key)
{
// 每次从ini中读取多少字节
System.Text.StringBuilder temp =new System.Text.StringBuilder(255);
// section=配置节，key=键名，temp=上面，path=路径
GetPrivateProfileString(section,key, "", temp, 255, sPath);
return temp.ToString();
}
}
}
开始调用函数。
// 写入ini
Ini ini = newIni("C:/config.ini");
ini.Writue("Setting","key1", "HELLO WORLD!");
ini.Writue("Setting","key2", "HELLO CHINA!");
// 读取ini
Ini ini = newIni("C:/config.ini");
string str1 =ini.ReadValue("Setting", "key1");
MessageBox.Show(str1);
二，在一些小的应用中，有时候不需要使用数据困这样大规模的数据管理工具，也很少进行数据的查询、修改等操作，而仅用文件来存储数据。这时就需要使用。net中的文件操作对象，如file、streamReader、streamWriter等。
1，使用File对象操作文件
System.IO.File类提供了一系类的静态办法，完成对晚间的常用操作，如新建、删除、拷贝、移动等
2，使用StreamWriter写入文件
在System.IO空间中定义了一个文件写入器对象StreamWriter，使用它可以以一种特定的编码向输出流中（Stream）写入字符。
3，使用SteamReader读取文件
与streamWrite对应
H. hibernate小问题求解：在实体类中的id定义的类型是String，在配置文件中如何设置
不要这样。另起一个字段，如xxxNo 的
I. 数据持久层中方法返回值为string类型，mybatis配置文件中怎么配置
select里面的resultClass="String"
J. 配置文件格式用哪个
App.config文件
1. 配置文件概述：
应用程序配置文件是标准的 XML 文件，XML 标记和属性是区分大小写的。它是可以按需要更改的，开发人员可以使用配置文件来更改设置，而不必重编译应用程序。配置文件的根节点是configuration。我们经常访问的是appSettings，它是由.Net预定义配置节。我们经常使用的配置文件的架构是象下面的形式。先大概有个印象，通过后面的实例会有一个比较清楚的认识。下面的“配置节”可以理解为进行配置一个XML的节点。
常见配置文件模式：
<configuration>
<configSections> //配置节声明区域，包含配置节和命名空间声明
<section> //配置节声明
<sectionGroup> //定义配置节组
<section> //配置节组中的配置节声明
<appSettings> //预定义配置节
<Custom element for configuration section> //配置节设置区域
2. 只有appSettings节的配置文件及访问方法
下面是一个最常见的应用程序配置文件的例子，只有appSettings节。
程序代码： [ 复制代码到剪贴板 ]
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<appSettings>
<add key="connectionstring" value="User ID=sa;Data Source=.;Password=;Initial Catalog=test;Provider=SQLOLEDB.1;" />
<add key="TemplatePATH" value="Template" />
</appSettings>
</configuration>
下面来看看这样的配置文件如何方法。
程序代码： [ 复制代码到剪贴板 ]
string _connectionString=ConfigurationSettings.AppSettings["connectionstring"];
使用ConfigurationSettings类的静态属性AppSettings就可以直接方法配置文件中的配置信息。这个属性的类型是NameValueCollection。
3. 自定义配置文件
3.1自定义配置节
一个用户自定义的配置节，在配置文件中分为两部分：一是在<configSections></ configSections> 配置节中声明配置节（上面配置文件模式中的“<section>”），另外是在<configSections>< / configSections >之后设置配置节（上面配置文件模式中的“< Custom element for configuration section>”），有点类似一个变量先声明，后使用一样。声明一个配置文件的语句如下：
<section name=" " type=" "/>
<section>：声明新配置节，即可创建新配置节。
name：自定义配置节的名称。
type：自定义配置节的类型，主要包括System.Configuration.SingleTagSectionHandler、 System.Configuration.DictionarySectionHandler、 System.Configuration.NameValueSectionHandler。
不同的type不但设置配置节的方式不一样，最后访问配置文件的操作上也有差异。下面我们就举一个配置文件的例子，让它包含这三个不同的type。
程序代码：
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<configSections>
<section name="Test1" type="System.Configuration.SingleTagSectionHandler"/>
<section name="Test2" type="System.Configuration.DictionarySectionHandler"/>
<section name="Test3" type="System.Configuration.NameValueSectionHandler" />
</configSections>
<Test1 setting1="Hello" setting2="World"/>
<Test2>
<add key="Hello" value="World" />
</Test2>
<Test3>
<add key="Hello" value="World" />
</Test3>
</configuration>
我们对上面的自定义配置节进行说明。在声明部分使用<section name="Test1" type= "System.Configuration.SingleTagSectionHandler"/>声明了一个配置节它的名字叫Test1，类型为SingleTagSectionHandler。在设置配置节部分使用 <Test1 setting1= "Hello" setting2="World"/>设置了一个配置节，它的第一个设置的值是Hello，第二个值是World，当然还可以有更多。其它的两个配置节和这个类似。
下面我们看在程序中如何访问这些自定义的配置节。我们用过ConfigurationSettings类的静态方法GetConfig来获取自定义配置节的信息。
程序代码： public static object GetConfig(string sectionName);
下面是访问这三个配置节的代码：
程序代码：
//访问配置节Test1
IDictionary IDTest1 = (IDictionary)ConfigurationSettings.GetConfig("Test1");
string str = (string)IDTest1["setting1"] +" "+(string)IDTest1["setting2"];
MessageBox.Show(str); //输出Hello World
//访问配置节Test1的方法2
string[] values1=new string[IDTest1.Count];
IDTest1.Values.CopyTo(values1,0);
MessageBox.Show(values1[0]+" "+values1[1]); //输出Hello World
//访问配置节Test2
IDictionary IDTest2 = (IDictionary)ConfigurationSettings.GetConfig("Test2");
string[] keys=new string[IDTest2.Keys.Count];
string[] values=new string[IDTest2.Keys.Count];
IDTest2.Keys.CopyTo(keys,0);
IDTest2.Values.CopyTo(values,0);
MessageBox.Show(keys[0]+" "+values[0]);
//访问配置节Test3
NameValueCollection nc=(NameValueCollection)ConfigurationSettings.GetConfig("Test3");
MessageBox.Show(nc.AllKeys[0].ToString()+" "+nc["Hello"]); //输出Hello World
通过上面的代码我们可以看出，不同的type通过GetConfig返回的类型不同，具体获得配置内容的方式也不一样。
[table]
配置节处理程序|返回类型[br]
[/table]
SingleTagSectionHandler Systems.Collections.IDictionary
DictionarySectionHandler Systems.Collections.IDictionary
NameValueSectionHandler Systems.Collections.Specialized.NameValueCollection
3.2自定义配置节组
配置节组是使用<sectionGroup>元素，将类似的配置节分到同一个组中。配置节组声明部分将创建配置节的包含元素，在< configSections>元素中声明配置节组，并将属于该组的节置于<sectionGroup>元素中。下面是一个包含配置节组的配置文件的例子：
复制代码 代码如下:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<configSections>
<sectionGroup name="TestGroup">
<section name="Test" type="System.Configuration.NameValueSectionHandler"/>
</sectionGroup>
</configSections>
<TestGroup>
<Test>
<add key="Hello" value="World"/>
</Test>
</TestGroup>
</configuration>