微信怎么修改密码_百度知道
微信怎么修改密码
提问者采纳
我的帐号～～独立密码
提问者评价
太给力了，你的回答完美解决了我的问题！
其他类似问题
63人觉得有用
按默认排序
其他5条回答
你好，微信修改密码方法/步骤首先上网搜索并下载一个最新版本微信客户端软件。下载完成后直接拷贝到手机SD卡中，然后利用手机自带的安装器进行安装。微信安装完成后，打开手机数据开关，然后直接运行已安装到手机上的微信程序。首次登陆微信时，可选择三种登陆方式（QQ号/微信号/手机号）中的任意一种进行登陆。在此为了方便好记，小编直接就用QQ号进行登陆。登陆完成后，微信程序要求输入一个专属于自己的名字，目地是方便朋友更容易认识你。在此小编就输入自己的百度ID：feifeidown，然后点击“下一步“。微信程序要求你输入”验证手机号“，直接输入本手机号即可，完成后直接点”下一步“，然后等待，当验证信息到达时直接点击”下一步“即可完成微信账号的注册过程。微信独立密码的设置方法：进入微信主界面，点击”设置”按钮。在新打开的界面中找到并进入“我的账号”选项菜单中。然后点击“独立密码”选项。
前不久我找 … 帮忙还不错而且他的技术也很棒。很快就给我搞定。 前不久我找 … 帮忙还不错而且他的技术也很棒。很快就给我搞定。前不久我找 … 帮忙还不错而且他的技术也很棒。很快就给我搞定。前不久我找 … 帮忙还不错而且他的技术也很棒。很快就给我搞定前不久我找 … 帮忙还不错而且他的技术也很棒。很快就给我搞定。 前不久我找 … 帮忙还不错而且他的技术也很棒。很快就给我搞定。前不久我找 … 帮忙还不错而且他的技术也很棒。很快就给我搞定。前不久我找 … 帮忙还不错而且他的技术也很棒。很快就给我搞定前不久我找 … 帮忙还不错而且他的技术也很棒。很快就给我搞定。前不久我找 … 帮忙还不错而且他的技术也很棒。很快就给我搞定
短信，验证码，填对了他会给你修改方式
QQ密码修改。微信也一样跟着修改了
修改密码的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁客服邮箱：
投诉邮箱：(转)spring施用jdbc进行数据库访问_2013腾讯编程马拉松复赛第二场一部分题解_6670周详用法（技巧篇）__脚本百事通
稍等，加载中……
^_^请注意，有可能下面的2篇文章才是您想要的内容：
(转)spring施用jdbc进行数据库访问
2013腾讯编程马拉松复赛第二场一部分题解
6670周详用法（技巧篇）
(转)spring施用jdbc进行数据库访问
(转)spring使用jdbc进行数据库访问
Spring JDBC抽象框架所带来的价值将在以下几个方面得以体现：（注：使用了Spring JDBC抽象框架之后，应用开发人员只需要完成斜体字部分的编码工作。）
指定数据库连接参数
打开数据库连接
声明SQL语句
预编译并执行SQL语句
遍历查询结果（如果需要的话）
处理每一次遍历操作
处理抛出的任何异常
关闭数据库连接
Spring将替我们完成所有单调乏味的JDBC底层细节处理工作。
Spring JDBC包结构
Spring JDBC抽象框架由四个包构成：core、 dataSource、object以及support。
org.springframework.jdbc.core包由JdbcTemplate类以及相关的回调接口（callback interface）和类组成。
org.springframework.jdbc.datasource包由一些用来简化DataSource访问的工具类，以及各种DataSource接口的简单实现(主要用于单元测试以及在J2EE容器之外使用JDBC)组成。工具类提供了一些静态方法，诸如通过JNDI获取数据连接以及在必要的情况下关闭这些连接。它支持绑定线程的连接，比如被用于DataSourceTransactionManager的连接。
接下来，org.springframework.jdbc.object包由封装了查询、更新以及存储过程的类组成，这些类的对象都是线程安全并且可重复使用的。它们类似于JDO，与JDO的不同之处在于查询结果与数据库是“断开连接”的。它们是在org.springframework.jdbc.core包的基础上对JDBC更高层次的抽象。
最后，org.springframework.jdbc.support包提供了一些SQLException的转换类以及相关的工具类。
在JDBC处理过程中抛出的异常将被转换成org.springframework.dao包中定义的异常。因此使用Spring JDBC进行开发将不需要处理JDBC或者特定的RDBMS才会抛出的异常。所有的异常都是unchecked exception，这样我们就可以对传递到调用者的异常进行有选择的捕获。
利用JDBC核心类实现JDBC的基本操作和错误处理
JdbcTemplate类
JdbcTemplate是core包的核心类。它替我们完成了资源的创建以及释放工作，从而简化了我们对JDBC的使用。它还可以帮助我们避免一些常见的错误，比如忘记关闭数据库连接。JdbcTemplate将完成JDBC核心处理流程，比如SQL语句的创建、执行，而把SQL语句的生成以及查询结果的提取工作留给我们的应用代码。它可以完成SQL查询、更新以及调用存储过程，可以对ResultSet进行遍历并加以提取。它还可以捕获JDBC异常并将其转换成org.springframework.dao包中定义的，通用的，信息更丰富的异常。
使用JdbcTemplate进行编码只需要根据明确定义的一组契约来实现回调接口。PreparedStatementCreator回调接口通过给定的Connection创建一个PreparedStatement，包含SQL和任何相关的参数。CallableStatementCreateor实现同样的处理，只不过它创建的是CallableStatement。RowCallbackHandler接口则从数据集的每一行中提取值。
我们可以在一个service实现类中通过传递一个DataSource引用来完成JdbcTemplate的实例化，也可以在application context中配置一个JdbcTemplate bean，来供service使用。需要注意的是DataSource在application context总是配制成一个bean，第一种情况下，DataSource bean将传递给service，第二种情况下DataSource bean传递给JdbcTemplate bean。因为JdbcTemplate使用回调接口和SQLExceptionTranslator接口作为参数，所以一般情况下没有必要通过继承JdbcTemplate来定义其子类。
JdbcTemplate中使用的所有SQL将会以“DEBUG”级别记入日志（一般情况下日志的category是JdbcTemplate相应的全限定类名，不过如果需要对JdbcTemplate进行定制的话，可能是它的子类名）。
NamedParameterJdbcTemplate类
NamedParameterJdbcTemplate类增加了在SQL语句中使用命名参数的支持。在此之前，在传统的SQL语句中，参数都是用'?'占位符来表示的。 NamedParameterJdbcTemplate类内部封装了一个普通的JdbcTemplate，并作为其代理来完成大部分工作。下面的内容主要针对NamedParameterJdbcTemplate与JdbcTemplate的不同之处来加以说明，即如何在SQL语句中使用命名参数。
通过下面的例子我们可以更好地了解NamedParameterJdbcTemplate的使用模式（在后面我们还有更好的使用方式）。
// some JDBC-backed DAO class...
public int countOfActorsByFirstName(String firstName) {
String sql = "select count(0) from T_ACTOR where first_name = :first_name";
NamedParameterJdbcTemplate template = new NamedParameterJdbcTemplate(this.getDataSource());
SqlParameterSource namedParameters = new MapSqlParameterSource("first_name", firstName);
return template.queryForInt(sql, namedParameters);
在上面例子中，sql变量使用了命名参数占位符“first_name”，与其对应的值存在namedParameters变量中（类型为MapSqlParameterSource）。
如果你喜欢的话，也可以使用基于Map风格的名值对将命名参数传递给NamedParameterJdbcTemplate（NamedParameterJdbcTemplate实现了NamedParameterJdbcOperations接口，剩下的工作将由调用该接口的相应方法来完成，这里我们就不再赘述）：
// some JDBC-backed DAO class...
public int countOfActorsByFirstName(String firstName) {
String sql = "select count(0) from T_ACTOR where first_name = :first_name";
NamedParameterJdbcTemplate template = new NamedParameterJdbcTemplate(this.getDataSource());
Map namedParameters = new HashMap();
namedParameters.put("first_name", firstName);
return template.queryForInt(sql, namedParameters);
另外一个值得一提的特性是与NamedParameterJdbcTemplate位于同一个包中的SqlParameterSource接口。在前面的代码片断中我们已经看到了该接口的实现（即MapSqlParameterSource类），SqlParameterSource可以用来作为NamedParameterJdbcTemplate命名参数的来源。MapSqlParameterSource类是一个非常简单的实现，它仅仅是一个java.util.Map适配器，当然其用法也就不言自明了（如果还有不明了的，可以在Spring的JIRA系统中要求提供更多的相关资料）。
SqlParameterSource接口的另一个实现－－BeanPropertySqlParameterSource为我们提供了更有趣的功能。该类包装一个类似JavaBean的对象，所需要的命名参数值将由包装对象提供，下面我们使用一个例子来更清楚地说明它的用法。
// some JavaBean-like class...
public class Actor {
private String firstN
private String lastN
public String getFirstName() {
return this.firstN
public String getLastName() {
return this.lastN
public Long getId() {
return this.
// setters omitted...
// some JDBC-backed DAO class...
public int countOfActors(Actor exampleActor) {
// notice how the named parameters match the properties of the above 'Actor' class
String sql = "select count(0) from T_ACTOR where first_name = :firstName and last_name = :lastName";
NamedParameterJdbcTemplate template = new NamedParameterJdbcTemplate(this.getDataSource());
SqlParameterSource namedParameters = new BeanPropertySqlParameterSource(exampleActor);
return template.queryForInt(sql, namedParameters);
大家必须牢记一点：NamedParameterJdbcTemplate类内部包装了一个标准的JdbcTemplate类。如果你需要访问其内部的JdbcTemplate实例（比如访问JdbcTemplate的一些方法）那么你需要使用getJdbcOperations()方法返回的JdbcOperations接口。（JdbcTemplate实现了JdbcOperations接口）。
NamedParameterJdbcTemplate类是线程安全的，该类的最佳使用方式不是每次操作的时候实例化一个新的NamedParameterJdbcTemplate，而是针对每个DataSource只配置一个NamedParameterJdbcTemplate实例（比如在Spring IoC容器中使用Spring IoC来进行配置），然后在那些使用该类的DAO中共享该实例。
SimpleJdbcTemplate类
请注意该类所提供的功能仅适用于Java 5 (Tiger)。
SimpleJdbcTemplate类是JdbcTemplate类的一个包装器（wrapper），它利用了Java 5的一些语言特性，比如Varargs和Autoboxing。对那些用惯了Java 5的程序员，这些新的语言特性还是很好用的。
SimpleJdbcTemplate 类利用Java 5的语法特性带来的好处可以通过一个例子来说明。在下面的代码片断中我们首先使用标准的JdbcTemplate进行数据访问，接下来使用SimpleJdbcTemplate做同样的事情。
// classic JdbcTemplate-style...
public Actor findActor(long id) {
String sql = "select id, first_name, last_name from T_ACTOR where id = ?";
RowMapper mapper = new RowMapper() {
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
Actor actor = new Actor();
actor.setId(rs.getLong(Long.valueOf(rs.getLong("id"))));
actor.setFirstName(rs.getString("first_name"));
actor.setLastName(rs.getString("last_name"));
// normally this would be dependency injected of course...
JdbcTemplate jdbcTemplate = new JdbcTemplate(this.getDataSource());
// notice the cast, and the wrapping up of the 'id' argument
// in an array, and the boxing of the 'id' argument as a reference type
return (Actor) jdbcTemplate.queryForObject(sql, mapper, new Object[] {Long.valueOf(id)});
下面是同一方法的另一种实现，惟一不同之处是我们使用了SimpleJdbcTemplate，这样代码显得更加清晰。
// SimpleJdbcTemplate-style...
public Actor findActor(long id) {
String sql = "select id, first_name, last_name from T_ACTOR where id = ?";
ParameterizedRowMapper&Actor& mapper = new ParameterizedRowMapper&Actor&() {
// notice the return type with respect to Java 5 covariant return types
public Actor mapRow(ResultSet rs, int rowNum) throws SQLException {
Actor actor = new Actor();
actor.setId(rs.getLong("id"));
actor.setFirstName(rs.getString("first_name"));
actor.setLastName(rs.getString("last_name"));
// again, normally this would be dependency injected of course...
SimpleJdbcTemplate simpleJdbcTemplate = new SimpleJdbcTemplate(this.getDataSource());
return simpleJdbcTemplate.queryForObject(sql, mapper, id);
DataSource接口
为了从数据库中取得数据，我们首先需要获取一个数据库连接。 Spring通过DataSource对象来完成这个工作。 DataSource是JDBC规范的一部分， 它被视为一个通用的数据库连接工厂。通过使用DataSource， Container或Framework可以将连接池以及事务管理的细节从应用代码中分离出来。 作为一个开发人员，在开发和测试产品的过程中，你可能需要知道连接数据库的细节。 但在产品实施时，你不需要知道这些细节。通常数据库管理员会帮你设置好数据源。
在使用Spring JDBC时，你既可以通过JNDI获得数据源，也可以自行配置数据源（ 使用Spring提供的DataSource实现类）。使用后者可以更方便的脱离Web容器来进行单元测试。 这里我们将使用DriverManagerDataSource，不过DataSource有多种实现， 后面我们会讲到。使用DriverManagerDataSource和你以前获取一个JDBC连接 的做法没什么两样。你首先必须指定JDBC驱动程序的全限定名，这样DriverManager 才能加载JDBC驱动类，接着你必须提供一个url（因JDBC驱动而异，为了保证设置正确请参考相关JDBC驱动的文档）， 最后你必须提供一个用户连接数据库的用户名和密码。下面我们将通过一个例子来说明如何配置一个 DriverManagerDataSource：
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("org.hsqldb.jdbcDriver");
dataSource.setUrl("jdbc:hsqldb:hsql://localhost:");
dataSource.setUsername("sa");
dataSource.setPassword("");
SQLExceptionTranslator接口
SQLExceptionTranslator是一个接口，如果你需要在 SQLException和org.springframework.dao.DataAccessException之间作转换，那么必须实现该接口。
转换器类的实现可以采用一般通用的做法(比如使用JDBC的SQLState code)，如果为了使转换更准确，也可以进行定制（比如使用Oracle的error code）。
SQLErrorCodeSQLExceptionTranslator是SQLExceptionTranslator的默认实现。 该实现使用指定数据库厂商的error code，比采用SQLState更精确。 转换过程基于一个JavaBean（类型为SQLErrorCodes）中的error code。 这个JavaBean由SQLErrorCodesFactory工厂类创建，其中的内容来自于 "sql-error-codes.xml"配置文件。该文件中的数据库厂商代码基于Database MetaData信息中的 DatabaseProductName，从而配合当前数据库的使用。
SQLErrorCodeSQLExceptionTranslator使用以下的匹配规则：
首先检查是否存在完成定制转换的子类实现。通常SQLErrorCodeSQLExceptionTranslator 这个类可以作为一个具体类使用，不需要进行定制，那么这个规则将不适用。
接着将SQLException的error code与错误代码集中的error code进行匹配。 默认情况下错误代码集将从SQLErrorCodesFactory取得。 错误代码集来自classpath下的sql-error-codes.xml文件， 它们将与数据库metadata信息中的database name进行映射。
如果仍然无法匹配，最后将调用fallbackTranslator属性的translate方法，SQLStateSQLExceptionTranslator类实例是默认的fallbackTranslator。
SQLErrorCodeSQLExceptionTranslator可以采用下面的方式进行扩展：
public class MySQLErrorCodesTranslator extends SQLErrorCodeSQLExceptionTranslator {
protected DataAccessException customTranslate(String task, String sql, SQLException sqlex) {
if (sqlex.getErrorCode() == -12345) {
return new DeadlockLoserDataAccessException(task, sqlex);
在上面的这个例子中，error code为'-12345'的SQLException 将采用该转换器进行转换，而其他的error code将由默认的转换器进行转换。 为了使用该转换器，必须将其作为参数传递给JdbcTemplate类 的setExceptionTranslator方法，并在需要使用这个转换器器的数据 存取操作中使用该JdbcTemplate。 下面的例子演示了如何使用该定制转换器：
// create a JdbcTemplate and set data source
JdbcTemplate jt = new JdbcTemplate();
jt.setDataSource(dataSource);
// create a custom translator and set the DataSource for the default translation lookup
MySQLErrorCodesTransalator tr = new MySQLErrorCodesTransalator();
tr.setDataSource(dataSource);
jt.setExceptionTranslator(tr);
// use the JdbcTemplate for this SqlUpdate
SqlUpdate su = new SqlUpdate();
su.setJdbcTemplate(jt);
su.setSql("update orders set shipping_charge = shipping_charge * 1.05");
su.compile();
su.update();
在上面的定制转换器中，我们给它注入了一个数据源，因为我们仍然需要 使用默认的转换器从sql-error-codes.xml中获取错误代码集。
执行SQL语句
我们仅需要非常少的代码就可以达到执行SQL语句的目的，一旦获得一个 DataSource和一个JdbcTemplate， 我们就可以使用JdbcTemplate提供的丰富功能实现我们的操作。 下面的例子使用了极少的代码完成创建一张表的工作。
import javax.sql.DataS
import org.springframework.jdbc.core.JdbcT
public class ExecuteAStatement {
private JdbcT
private DataSource dataS
public void doExecute() {
jt = new JdbcTemplate(dataSource);
jt.execute("create table mytable (id integer, name varchar(100))");
public void setDataSource(DataSource dataSource) {
this.dataSource = dataS
除了execute方法之外，JdbcTemplate还提供了大量的查询方法。 在这些查询方法中，有很大一部分是用来查询单值的。比如返回一个汇总（count）结果 或者从返回行结果中取得指定列的值。这时我们可以使用queryForInt(..)、 queryForLong(..)或者queryForObject(..)方法。 queryForObject方法用来将返回的JDBC类型对象转换成指定的Java对象，如果类型转换失败将抛出 InvalidDataAccessApiUsageException异常。 下面的例子演示了两个查询的用法，一个返回int值，另一个返回 String。
import javax.sql.DataS
import org.springframework.jdbc.core.JdbcT
public class RunAQuery {
private JdbcT
private DataSource dataS
public int getCount() {
jt = new JdbcTemplate(dataSource);
int count = jt.queryForInt("select count(*) from mytable");
public String getName() {
jt = new JdbcTemplate(dataSource);
String name = (String) jt.queryForObject("select name from mytable", String.class);
public void setDataSource(DataSource dataSource) {
this.dataSource = dataS
除了返回单值的查询方法，JdbcTemplate还提供了一组返回List结果 的方法。List中的每一项对应查询返回结果中的一行。其中最简单的是queryForList方法， 该方法将返回一个List，该List中的每一条 记录是一个Map对象，对应应数据库中某一行；而该Map 中的每一项对应该数据库行中的某一列值。下面的代码片断接着上面的例子演示了如何用该方法返回表中 所有记录：
public List getList() {
jt = new JdbcTemplate(dataSource);
List rows = jt.queryForList("select * from mytable");
返回的结果集类似下面这种形式：
[{name=Bob, id=1}, {name=Mary, id=2}]
更新数据库
JdbcTemplate还提供了一些更新数据库的方法。 在下面的例子中，我们根据给定的主键值对指定的列进行更新。 例子中的SQL语句中使用了“?”占位符来接受参数（这种做法在更新和查询SQL语句中很常见）。 传递的参数值位于一个对象数组中（基本类型需要被包装成其对应的对象类型）。
import javax.sql.DataS
import org.springframework.jdbc.core.JdbcT
public class ExecuteAnUpdate {
private JdbcT
private DataSource dataS
public void setName(int id, String name) {
jt = new JdbcTemplate(dataSource);
jt.update("update mytable set name = ? where id = ?", new Object[] {name, new Integer(id)});
public void setDataSource(DataSource dataSource) {
this.dataSource = dataS
控制数据库连接
DataSourceUtils类
DataSourceUtils作为一个帮助类提供易用且强大的数据库访问能力， 我们可以使用该类提供的静态方法从JNDI获取数据库连接以及在必要的时候关闭之。 它提供支持线程绑定的数据库连接（比如使用DataSourceTransactionManager 的时候，将把数据库连接绑定到当前的线程上）。
注：getDataSourceFromJndi(..)方法主要用于那些没有使用bean factory 或者application context的场合。如果使用application context，那么最好是在 JndiObjectFactoryBean中配置bean或者直接使用 JdbcTemplate实例。JndiObjectFactoryBean 能够通过JNDI获取DataSource并将 DataSource作为引用参数传递给其他bean。 这样，在不同的DataSource之间切换只需要修改配置文件即可， 甚至我们可以用一个非JNDI的DataSource来替换 FactoryBean定义！
SmartDataSource接口
SmartDataSource是DataSource 接口的一个扩展，用来提供数据库连接。使用该接口的类在指定的操作之后可以检查是否需要关闭连接。 该接口在某些情况下非常有用，比如有些情况需要重用数据库连接。
AbstractDataSource类
AbstractDataSource是一个实现了DataSource 接口的abstract基类。它实现了DataSource接口的 一些无关痛痒的方法，如果你需要实现自己的DataSource，那么继承 该类是个好主意。
SingleConnectionDataSource类
SingleConnectionDataSource是SmartDataSource接口 的一个实现，其内部包装了一个单连接。该连接在使用之后将不会关闭，很显然它不能在多线程 的环境下使用。
当客户端代码调用close方法的时候，如果它总是假设数据库连接来自连接池（就像使用持久化工具时一样）， 你应该将suppressClose设置为true。 这样，通过该类获取的将是代理连接（禁止关闭）而不是原有的物理连接。 需要注意的是，我们不能把使用该类获取的数据库连接造型（cast）为Oracle Connection之类的本地数据库连接。
SingleConnectionDataSource主要在测试的时候使用。 它使得测试代码很容易脱离应用服务器而在一个简单的JNDI环境下运行。 与DriverManagerDataSource不同的是，它始终只会使用同一个数据库连接， 从而避免每次建立物理连接的开销。
DriverManagerDataSource类
DriverManagerDataSource类实现了 SmartDataSource接口。在applicationContext.xml中可以使用 bean properties来设置JDBC Driver属性，该类每次返回的都是一个新的连接。
该类主要在测试以及脱离J2EE容器的独立环境中使用。它既可以用来在application context中作为一个 DataSource bean，也可以在简单的JNDI环境下使用。 由于Connection.close()仅仅只是简单的关闭数据库连接，因此任何能够获取 DataSource的持久化代码都能很好的工作。不过使用JavaBean风格的连接池 （比如commons-dbcp）也并非难事。即使是在测试环境下，使用连接池也是一种比使用 DriverManagerDataSource更好的做法。
TransactionAwareDataSourceProxy类
TransactionAwareDataSourceProxy作为目标DataSource的一个代理， 在对目标DataSource包装的同时，还增加了Spring的事务管理能力， 在这一点上，这个类的功能非常像J2EE服务器所提供的事务化的JNDI DataSource。
该类几乎很少被用到，除非现有代码在被调用的时候需要一个标准的 JDBC DataSource接口实现作为参数。 这种情况下，这个类可以使现有代码参与Spring的事务管理。通常最好的做法是使用更高层的抽象 来对数据源进行管理，比如JdbcTemplate和DataSourceUtils等等。
如果需要更详细的资料，请参考TransactionAwareDataSourceProxy JavaDoc 。
DataSourceTransactionManager类
DataSourceTransactionManager类是 PlatformTransactionManager接口的一个实现，用于处理单JDBC数据源。 它将从指定DataSource取得的JDBC连接绑定到当前线程，因此它也支持了每个数据源对应到一个线程。
我们推荐在应用代码中使用DataSourceUtils.getConnection(DataSource)来获取 JDBC连接，而不是使用J2EE标准的DataSource.getConnection。因为前者将抛出 unchecked的org.springframework.dao异常，而不是checked的 SQLException异常。Spring Framework中所有的类（比如 JdbcTemplate）都采用这种做法。如果不需要和这个 DataSourceTransactionManager类一起使用，DataSourceUtils 提供的功能跟一般的数据库连接策略没有什么两样，因此它可以在任何场景下使用。
DataSourceTransactionManager类支持定制隔离级别，以及对SQL语句查询超时的设定。 为了支持后者，应用代码必须使用JdbcTemplate或者在每次创建SQL语句时调用 DataSourceUtils.applyTransactionTimeout方法。
在使用单个数据源的情形下，你可以用DataSourceTransactionManager来替代JtaTransactionManager， 因为DataSourceTransactionManager不需要容器支持JTA。如果你使用DataSourceUtils.getConnection(DataSource)来获取 JDBC连接，二者之间的切换只需要更改一些配置。最后需要注意的一点就是JtaTransactionManager不支持隔离级别的定制！
用Java对象来表达JDBC操作
org.springframework.jdbc.object包下的类允许用户以更加 面向对象的方式去访问数据库。比如说，用户可以执行查询并返回一个list， 该list作为一个结果集将把从数据库中取出的列数据映射到业务对象的属性上。 用户也可以执行存储过程，以及运行更新、删除以及插入SQL语句。
在许多Spring开发人员中间存在有一种观点，那就是下面将要提到的各种RDBMS操作类 （StoredProcedure类除外） 通常也可以直接使用JdbcTemplate相关的方法来替换。 相对于把一个查询操作封装成一个类而言，直接调用JdbcTemplate方法将更简单 而且更容易理解。
必须说明的一点就是，这仅仅只是一种观点而已， 如果你认为你可以从直接使用RDBMS操作类中获取一些额外的好处， 你不妨根据自己的需要和喜好进行不同的选择。
SqlQuery类
SqlQuery是一个可重用、线程安全的类，它封装了一个SQL查询。 其子类必须实现newResultReader()方法，该方法用来在遍历 ResultSet的时候能使用一个类来保存结果。 我们很少需要直接使用SqlQuery，因为其子类 MappingSqlQuery作为一个更加易用的实现能够将结果集中的行映射为Java对象。 SqlQuery还有另外两个扩展分别是 MappingSqlQueryWithParameters和UpdatableSqlQuery。
MappingSqlQuery类
MappingSqlQuery是一个可重用的查询抽象类，其具体类必须实现 mapRow(ResultSet, int)抽象方法来将结果集中的每一行转换成Java对象。
在SqlQuery的各种实现中， MappingSqlQuery是最常用也是最容易使用的一个。
下面这个例子演示了一个定制查询，它将从客户表中取得的数据映射到一个 Customer类实例。
private class CustomerMappingQuery extends MappingSqlQuery {
public CustomerMappingQuery(DataSource ds) {
super(ds, "SELECT id, name FROM customer WHERE id = ?");
super.declareParameter(new SqlParameter("id", Types.INTEGER));
compile();
public Object mapRow(ResultSet rs, int rowNumber) throws SQLException {
Customer cust = new Customer();
cust.setId((Integer) rs.getObject("id"));
cust.setName(rs.getString("name"));
在上面的例子中，我们为用户查询提供了一个构造函数并为构造函数传递了一个 DataSource参数。在构造函数里面我们把 DataSource和一个用来返回查询结果的SQL语句作为参数 调用父类的构造函数。SQL语句将被用于生成一个PreparedStatement对象， 因此它可以包含占位符来传递参数。而每一个SQL语句的参数必须通过调用 declareParameter方法来进行声明，该方法需要一个 SqlParameter（封装了一个字段名字和一个 java.sql.Types中定义的JDBC类型）对象作为参数。 所有参数定义完之后，我们调用compile()方法来对SQL语句进行预编译。
下面让我们看看该定制查询初始化并执行的代码：
public Customer getCustomer(Integer id) {
CustomerMappingQuery custQry = new CustomerMappingQuery(dataSource);
Object[] parms = new Object[1];
parms[0] =
List customers = custQry.execute(parms);
if (customers.size() & 0) {
return (Customer) customers.get(0);
在上面的例子中，getCustomer方法通过传递惟一参数id来返回一个客户对象。 该方法内部在创建CustomerMappingQuery实例之后， 我们创建了一个对象数组用来包含要传递的查询参数。这里我们只有唯一的一个 Integer参数。执行CustomerMappingQuery的 execute方法之后，我们得到了一个List，该List中包含一个 Customer对象，如果有对象满足查询条件的话。
SqlUpdate类
SqlUpdate类封装了一个可重复使用的SQL更新操作。 跟所有RdbmsOperation类一样，SqlUpdate可以在SQL中定义参数。
该类提供了一系列update()方法，就像SqlQuery提供的一系列execute()方法一样。
SqlUpdate是一个具体的类。通过在SQL语句中定义参数，这个类可以支持 不同的更新方法，我们一般不需要通过继承来实现定制。
import java.sql.T
import javax.sql.DataS
import org.springframework.jdbc.core.SqlP
import org.springframework.jdbc.object.SqlU
public class UpdateCreditRating extends SqlUpdate {
public UpdateCreditRating(DataSource ds) {
setDataSource(ds);
setSql("update customer set credit_rating = ? where id = ?");
declareParameter(new SqlParameter(Types.NUMERIC));
declareParameter(new SqlParameter(Types.NUMERIC));
compile();
* @param id for the Customer to be updated
* @param rating the new value for credit rating
* @return number of rows updated
public int run(int id, int rating) {
Object[] params =
new Object[] {
new Integer(rating),
new Integer(id)};
return update(params);
StoredProcedure类
StoredProcedure类是一个抽象基类，它是对RDBMS存储过程的一种抽象。 该类提供了多种execute(..)方法，不过这些方法的访问类型都是protected的。
从父类继承的sql属性用来指定RDBMS存储过程的名字。 尽管该类提供了许多必须在JDBC3.0下使用的功能，但是我们更关注的是JDBC 3.0中引入的命名参数特性。
下面的程序演示了如何调用Oracle中的sysdate()函数。 这里我们创建了一个继承StoredProcedure的子类，虽然它没有输入参数， 但是我必须通过使用SqlOutParameter来声明一个日期类型的输出参数。 execute()方法将返回一个map，map中的每个entry是一个用参数名作key， 以输出参数为value的名值对。
import java.sql.T
import java.util.HashM
import java.util.I
import java.util.M
import javax.sql.DataS
import org.springframework.jdbc.core.SqlOutP
import org.springframework.jdbc.datasource.*;
import org.springframework.jdbc.object.StoredP
public class TestStoredProcedure {
public static void main(String[] args)
TestStoredProcedure t = new TestStoredProcedure();
System.out.println("Done!");
void test() {
DriverManagerDataSource ds = new DriverManagerDataSource();
ds.setDriverClassName("oracle.jdbc.OracleDriver");
ds.setUrl("jdbc:oracle:thin:@localhost:1521:mydb");
ds.setUsername("scott");
ds.setPassword("tiger");
MyStoredProcedure sproc = new MyStoredProcedure(ds);
Map results = sproc.execute();
printMap(results);
private class MyStoredProcedure extends StoredProcedure {
private static final String SQL = "sysdate";
public MyStoredProcedure(DataSource ds) {
setDataSource(ds);
setFunction(true);
setSql(SQL);
declareParameter(new SqlOutParameter("date", Types.DATE));
compile();
public Map execute() {
// the 'sysdate' sproc has no input parameters, so an empty Map is supplied...
return execute(new HashMap());
private static void printMap(Map results) {
for (Iterator it = results.entrySet().iterator(); it.hasNext(); ) {
System.out.println(it.next());
下面是StoredProcedure的另一个例子，它使用了两个Oracle游标类型的输出参数。
import oracle.jdbc.driver.OracleT
import org.springframework.jdbc.core.SqlOutP
import org.springframework.jdbc.object.StoredP
import javax.sql.DataS
import java.util.HashM
import java.util.M
public class TitlesAndGenresStoredProcedure extends StoredProcedure {
private static final String SPROC_NAME = "AllTitlesAndGenres";
public TitlesAndGenresStoredProcedure(DataSource dataSource) {
super(dataSource, SPROC_NAME);
declareParameter(new SqlOutParameter("titles", OracleTypes.CURSOR, new TitleMapper()));
declareParameter(new SqlOutParameter("genres", OracleTypes.CURSOR, new GenreMapper()));
compile();
public Map execute() {
// again, this sproc has no input parameters, so an empty Map is supplied...
return super.execute(new HashMap());
值得注意的是TitlesAndGenresStoredProcedure构造函数中 declareParameter(..)的SqlOutParameter参数， 该参数使用了RowMapper接口的实现。 这是一种非常方便而强大的重用方式。 下面我们来看一下RowMapper的两个具体实现。
首先是TitleMapper类，它简单的把ResultSet中的每一行映射为一个Title Domain Object。
import com.foo.sprocs.domain.T
import org.springframework.jdbc.core.RowM
import java.sql.ResultS
import java.sql.SQLE
public final class TitleMapper implements RowMapper {
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
Title title = new Title();
title.setId(rs.getLong("id"));
title.setName(rs.getString("name"));
另一个是GenreMapper类，也是非常简单的将ResultSet中的每一行映射为一个Genre Domain Object。
import org.springframework.jdbc.core.RowM
import java.sql.ResultS
import java.sql.SQLE
import com.foo.domain.G
public final class GenreMapper implements RowMapper {
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
return new Genre(rs.getString("name"));
如果你需要给存储过程传输入参数（这些输入参数是在RDBMS存储过程中定义好了的）， 则需要提供一个指定类型的execute(..)方法， 该方法将调用基类的protected execute(Map parameters)方法。 例如：
import oracle.jdbc.driver.OracleT
import org.springframework.jdbc.core.SqlOutP
import org.springframework.jdbc.object.StoredP
import javax.sql.DataS
import java.util.HashM
import java.util.M
public class TitlesAfterDateStoredProcedure extends StoredProcedure {
private static final String SPROC_NAME = "TitlesAfterDate";
private static final String CUTOFF_DATE_PARAM = "cutoffDate";
public TitlesAfterDateStoredProcedure(DataSource dataSource) {
super(dataSource, SPROC_NAME);
declaraParameter(new SqlParameter(CUTOFF_DATE_PARAM, Types.DATE);
declareParameter(new SqlOutParameter("titles", OracleTypes.CURSOR, new TitleMapper()));
compile();
public Map execute(Date cutoffDate) {
Map inputs = new HashMap();
inputs.put(CUTOFF_DATE_PARAM, cutoffDate);
return super.execute(inputs);
SqlFunction类
SqlFunction RDBMS操作类封装了一个SQL“函数”包装器（wrapper）， 该包装器适用于查询并返回一个单行结果集。默认返回的是一个int值， 不过我们可以采用类似JdbcTemplate中的queryForXxx 做法自己实现来返回其它类型。SqlFunction优势在于我们不必创建 JdbcTemplate，这些它都在内部替我们做了。
该类的主要用途是调用SQL函数来返回一个单值的结果集，比如类似“select user()”、 “select sysdate from dual”的查询。如果需要调用更复杂的存储函数， 可以使用StoredProcedure或SqlCall。
SqlFunction是一个具体类，通常我们不需要它的子类。 其用法是创建该类的实例，然后声明SQL语句以及参数就可以调用相关的run方法去多次执行函数。 下面的例子用来返回指定表的记录行数：
public int countRows() {
SqlFunction sf = new SqlFunction(dataSource, "select count(*) from mytable");
sf.compile();
return sf.run();
2013腾讯编程马拉松复赛第二场一部分题解
2013腾讯编程马拉松复赛第二场部分题解最近真是太水啦，就拿昨天的比赛来说，只过了一道。。。，最后一道因为一个变量写反啦，一直WA到比赛结束，直接导致我没有看到1002这道大水题。。。唉，看来我真不是比赛型选手，今天把做了下，补个题解吧。
http://acm./showproblem.php?pid=4535
吉哥系列故事——礼尚往来
吉哥还是那个吉哥
　　那个江湖人称“叽叽哥”的基哥
　　每当节日来临，女友众多的叽叽哥总是能从全国各地的女友那里收到各种礼物。
　　有礼物收到当然值得高兴，但回礼确是件麻烦的事！
　　无论多麻烦，总不好意思收礼而不回礼，那也不是叽叽哥的风格。
　　现在，即爱面子又抠门的叽叽哥想出了一个绝妙的好办法：他准备将各个女友送来的礼物合理分配，再回送不同女友，这样就不用再花钱买礼物了！
　　假设叽叽哥的n个女友每人送他一个礼物（每个人送的礼物都不相同），现在他需要合理安排，再回送每个女友一份礼物，重点是，回送的礼物不能是这个女友之前送他的那个礼物，不然，叽叽哥可就摊上事了，摊上大事了......
　　现在，叽叽哥想知道总共有多少种满足条件的回送礼物方案呢？
1001：有公式的，亏我还推了半天，数据量也不大，直接根据公式推就行，水题就不说了。。。
http://acm./showproblem.php?pid=4536
XCOM Enemy Unknown
XCOM-Enemy Unknown是一款很好玩很经典的策略游戏.
在游戏中,由于未知的敌人--外星人入侵,你团结了世界各大国家进行抵抗.
随着游戏进展,会有很多的外星人进攻事件.每次进攻外星人会选择3个国家攻击,作为联盟的指挥者,你要安排有限的联盟军去支援其中一个国家,抵抗进攻这个国家的外星人.
战斗胜利之后这个被支援的国家恐慌值就会-2点(恐慌值最少减为1),而其他两个未被支援的国家恐慌值就会+2点,同时和这两个国家在相同大洲的其他国家恐慌值也会+1点.
当一个国家的恐慌值超过5点,这个国家就会对联盟失去信心从而退出联盟.
现在给你外星人将会进攻的地点,问你最多能在不失去任何一个国家信任的情况下抵挡多少次外星人的进攻.
1002：啊啊啊，没看清数据量，没想到是DFS啊，我还蛋疼地想网络流啊。。。呜呜呜，今天写了个超级暴力的DFS过了，竟然才15ms。。。。直接枚举每一次的拯救目标就行，适当加些剪枝。代码如下：
#include &iostream&
#include &string.h&
#include &stdio.h&
#include &algorithm&
#define maxn 100010
#include &vector&
int ask[110][3];
int aa[20];
int v[20];
int t[6][110];
int len[6];
int dfs(int num)
int i,j,ans=0;
for(i=0;i&3;i++)
int a=ask[num][i],b=ask[num][(i+1)%3],c=ask[num][(i+2)%3];
if(aa[b]&3||aa[c]&3)
int tru=1,sum=len[v[b]];
for(j=0;j&j++)
if(aa[t[v[b]][j]]==5)
sum=len[v[c]];
for(j=0;j&j++)
if(aa[t[v[c]][j]]==5)
sum=len[v[c]];
for(j=0;j&j++)
aa[t[v[c]][j]]++;
sum=len[v[b]];
for(j=0;j&j++)
aa[t[v[b]][j]]++;
int tmp=aa[a];
aa[a]=max(1,aa[a]-2);
ans=max(ans,max(num,dfs(num+1)));
sum=len[v[c]];
for(j=0;j&j++)
aa[t[v[c]][j]]--;
sum=len[v[b]];
for(j=0;j&j++)
aa[t[v[b]][j]]--;
int main()
freopen("dd.txt","r",stdin);
int ncase,time=0;
scanf("%d",&ncase);
while(ncase--)
int n,m,i;
printf("Case #%d: ",++time);
scanf("%d%d%d",&n,&m,&k);
memset(len,0,sizeof(len));
for(i=0;i&n;i++)
scanf("%d",&v[i]);
t[v[i]][len[v[i]]++]=i;
for(i=0;i&n;i++)
scanf("%d",&aa[i]);
for(i=1;i&=k;i++)
scanf("%d%d%d",&ask[i][0],&ask[i][1],&ask[i][2]);
int ans=dfs(1);
printf("%d\n",ans);
http://acm./showproblem.php?pid=4539
郑厂长系列故事——排兵布阵
郑厂长不是正厂长
　　也不是副厂长
　　他根本就不是厂长
　　事实上
　　他是带兵打仗的团长
　　一天，郑厂长带着他的军队来到了一个n*m的平原准备布阵。
　　根据以往的战斗经验，每个士兵可以攻击到并且只能攻击到与之曼哈顿距离为2的位置以及士兵本身所在的位置。当然，一个士兵不能站在另外一个士兵所能攻击到的位置，同时因为地形的原因平原上也不是每一个位置都可以安排士兵。
　　现在，已知n,m 以及平原阵地的具体地形，请你帮助郑厂长计算该阵地,最多能安排多少个士兵。
1005：这是昨天的啃死爹题，因为一个傻逼错误WA到最后。。。这道题一般人一看就知道是状态压缩ＤＰ了吧，但是我不是一般人啊，我是大傻Ｘ啊，就是只会往最大独立集去想啊。。。然后还没想出来啊。。。
经典的状态压缩ＤＰ，我这ＤＰ水货遇到ＤＰ就怂。。。我们设dp[i][pre][now]表示第ｉ行为ｎｏｗ状态，第i-1行为pre状态时可以安排的最大士兵数量，这里的状态指的是每一行的士兵安排情况，我们把状态用二进制表示出来后，第ｉ位为１表示在第ｉ列放置一个士兵，为０表示不放，因为m&=10所以我们最多只要１０２４个状态就可以表示一行的每一个状态，事实上这１０２４个状态中有大部分是不合法的，（也就是有两个１其距离为２），所以我们可以预处理出所有的合法状态，（我们下面所讨论的状态都是合法的），对于dp[i][pre][now]我要怎么计算呢？
首先当然是这两个状态不能和所给的矩阵有冲突（也就是在不能人的地方放置了人），然后相邻两行不能有距离为２的１存在。满足上面的条件后，则dp[i][pre][now]=max(dp[i-1][ppre][pre]),其中ppre也要状态也要满足以上条件。我们最后求合法状态中的最大值即可，以上快速判断是否满足要求可以用位运算来判断，具体如何用请自己思考，或者参考我的代码。
#include &iostream&
#include &string.h&
#include &algorithm&
#include &stdio.h&
#include &vector&
int dp[200][200][200];
vector&int& a[11];
int check(int x,int len)
for(i=0;i&len-2;i++)
int tmp=(1&&i)+(1&&(i+2));
if((tmp&x)==tmp)
int cot[1100];
int getnum(int x)
int sum=0;
void init()
for(i=0;i&=1024;i++)
cot[i]=getnum(i);
for(i=1;i&=10;i++)
tmp=(1&&i)-1;
a[i].push_back(0);
for(j=1;j&=j++)
if(check(j,i))
a[i].push_back(j);
int max(int a,int b)
return a&b?a:b;
int num[110];
int main()
int n,m,x;
while(scanf("%d%d",&n,&m)!=EOF)
memset(dp,0,sizeof(dp));
for(i=1;i&=n;i++)
for(j=1;j&=m;j++)
scanf("%d",&x);
tmp=tmp*2+x;
tmp=a[m].size();
int ans=0;
for(i=0;i&i++)
if((num[1]|a[m][i])==num[1])//判断是否满足棋盘
int now=a[m][i];
dp[1][0][i]=cot[now];
ans=max(ans,dp[1][0][i]);
for(i=2;i&=n;i++)
for(j=0;j&j++)
if((num[i]|a[m][j])==num[i])//状态满足第i行
int now=a[m][j];
for(s=0;s&s++)
int pre=a[m][s];
if((num[i-1]|pre)==num[i-1])
if(((now&&1)&pre)==0&&((now&&1)&pre)==0)
dp[i][s][j]=dp[1][0][s]+cot[now];
for(t=0;t&t++)
int ppre=a[m][t];
if((num[i-2]|ppre)==num[i-2])
if((ppre&now)==0)
if(((ppre&&1)&pre)==0&&((ppre&&1)&pre)==0)
dp[i][s][j]=max(dp[i][s][j],dp[i-1][t][s]+cot[now]);
ans=max(ans,dp[i][s][j]);
printf("%d\n",ans);
6670周详用法（技巧篇）
6670详尽用法（技巧篇）
一、格式化手机在手机垃圾文件太多，严重错误无法恢复或手机出现异常的情况下进行格机，格机将会把C：盘内容全部清空，再写入新的系统信息，所以格机前建议在格式化之前先进行手机资料的备份。进行格式化时必需要有充足电量保证，足够维持操作过程所需。
1）软格机 操作方法：1）命令操作是输入*#7370#,原始密码12345。2）或者到设置里去进行恢复出厂设置，密码同上3）或者也可利用软件来格式化比如systemtool等一般情况下可在开机的时候按住“笔型键”进入安全模式，这样可以以干净的系统下操作，避免一些开机自启动的软件的影响。另外需要注意的是，有一些开机启动常驻内存的软件比如Q9、T9字库运行的话，用此法格式化是无效的,需要把相应的Q9关闭后才可格式化成功。
2）硬格机 操作方法：先关机，同时按住拨号键、“*”键、“3”键，然后打开电源直到“NOKIA”字样出现，此过程不能松开任何一个按键，稍稍等几秒直至出现“Formating……/”字样，这时方可松开按键。3~5分钟后系统格式化完成，手机自动重启并进入待机画面，重新输入手机时间。 此格式化比较彻底，不会出现格式化无效的问题。
3）通过软件格
安装System Tools软件，里面有个格式化选项，可以不需要输入锁码来格机。　　以上格机有几点需要注意：保持电量绝对充足，格机途中不能企图关机，不能插充电器等，如违反了有可能造成烧机等严重的后果。还有硬格可能对机器硬件有点损伤，不是万不得以，机器无法开机的情况下不要使用硬格，还有一点要注意，格机后会使线路2消失，必须到KF刷机才能恢复。 4）格式化存储卡附加功能--存储卡--选项--格式化存储卡，开始格式化。整个格式化的过程稍长，如果是128容量的MMC卡，完成格式化的过程大概需要8分钟左右。如果有读卡器的话，可以在电脑上使用读卡器来进行格式化，这样时间会短些。不过需要注意的是，如果用读卡器在电脑上格式化MMC，一定要把文件格式改成“FAT”或“FAT16”，格式化完成时会提示输入存储卡名称。格式化好了后，E盘中有5个手机自行创建的文件夹，分别是images，others，sounds，system，videos。但如果使用读卡器进行格式化的话，则需要自己新建这5个文件夹二、后台程序6670的Symbian　OS是多任务操作系统，可以同时运行多个程序。直接按挂断键或功能键退出时，程序并没有关闭，只是转入后台运行，继续占用内存。如果需要退出后台程序，可以长按*键，会跳出一个后台运行的程序列表，可以查看尚未关闭并且正在运行的程序，选择进入或“C键”关闭。三、桌面整理程序越装越多后，桌面可建立一些文件夹来进行归类。进入9宫桌面可直接按1~9数字键对应位置直接按键进入。四、连接
1）PC连接PC套件与诺基亚DKU-2数据线配合使用，请先安装usb数据线驱动程序，然后安装PC套件。卸载时先删除数据线的程序，再删除管理软件。最新版本的PC套件已经不用安装usb数据线驱动程序了。
2）蓝牙连接安装蓝牙适配器的驱动程序。然后在6670里打开蓝牙连接，在pc控制面板的“诺基亚连接管理器”里设置以后即可通过pc套件的pc浏览器进行文件传送。另外，可在蓝牙驱动中设置文件传输方式，并设置pc接收目录夹。完成后，即可在手机里将文件通过蓝牙直接发送到pc接收目录中，非常方便。pc传送数据到手机也可点鼠标右键，然后通过蓝牙发送，文件将以短信的形式传送到手机，打开短信即可运行程序。如果是一般文件，则需要到:\system\mail下查找。　3）读卡器连接读卡器连接速度快，适用于需要复制大量文件或者大容量文件的时候。另外使用pc套件无法进入系统目录下，无法传送整个文件夹，需要手动建立子目录，然后把文件一一传到手机。如果使用读卡器则非常方便，并且可以直接到达系统文件夹system下。五、软件、游戏安装和卸载软件、游戏、主题桌面程序都为symbian系统的程序，安装卸载原理都是相同的。
1）安装安装程序文件通常有sis、jar格式。sis是symbian程序的安装文件，jar是java程序安装文件，只要在6670自带的文件管理里直接开启即可安装。尽量把程序安装在mmc卡上，保持较大的机器空间对提高机器的稳定性有好处，但一些常用小程序也可安装在c盘，可以节省读取时间和频繁读取mmc卡的耗电。主题桌面程序sis可直接安装,已经解开的手动复制到c/system/skins目录
2）卸载所有程序必须在关闭后才能正常卸载。有一些常驻内存的程序尤其要关闭后才能卸载，否则将会出现错误。正常安装的程序请到程序管理中的列表里找到后卸载。如果是手动安装的程序，手动进入相应目录，进行手动删除。六、文件管理手机有c、d、e、z四个盘。C（系统存储），D（虚拟缓存），E（存储卡）， Z（ROM只读）。可操作的为C与E盘。可以文件管理 软件FileMan进行文件管理。还有一个SELEQ 文件管理 软件。七、音乐、铃声支持mp3、acc、wav、amr(awb)、midi格式，铃声需要放到E\sounds\下才可在情景模式中找到并且设定。6670采用的是单声道，同时只配单耳耳机，表现能力有限，mp3格式用32000hz 48kbps 单声道编码即可，wav格式用pcm wav 22000hz 4bit单声道编码即可八、图片支持jpeg、BMP格式，背景需要放到E\images\下才可在情景模式或多媒体中找到并且设定。全屏像素格式176*208或352*416(一倍),需做成主题安装，才全屏显示；背景像素格式144*176或288*352(一倍),可以做壁纸。6670本身不支持动态的GIF 图片 做壁纸的，但是可以通过安装第三方软件来支持的九、网络LOGO像素格式97*25, 位置c:\system\apps\phone\oplogo\460_x_x.bmp，这个460_x_x.bmp就是LOGO文件，S60只支持bmp格式，移动的是460_0_0.bmp，联通的是460_1_0.bmp。logo是针对服务商的，可以分别设置，两个服务商的logo不相干扰。把bmp文件放到c:\system\apps\phone\oplogo\里替换同名文件，重启就达到换logo的目的了。十、视频系统自带realplayer播放3gp,rm，mp4格式的电影，不过分辨率必须是176*144；　　AVI电影可以使用SmartMovie这个软件来全屏观看的，分辨率的要求是176*208；　　MP4电影可以专门使用PVPlayer这个软件来观看的。十一、游戏
1)jar,sis格式可直接安装。
2)blz格式是ng游戏的安装程序，需要先安装blzinstapp.sis模拟平台，把blz的文件放在你的E盘根目录,然后在这个平台里安装选择blz程序安装。
3)gbc格式是GB游戏的安装程序,需要先安装goboy.sis模拟平台, 然后在这个平台里安装选择gbc程序安装.一般把游戏文件改成英文名安装后才可正常运行已经解开的程序文件夹，手动复制到E\system\apps。安装汉化文件(rsc格式)、破解程序(app格式)时把文件放到一文件夹中（E/others），然后将汉化文件剪切到软件安装处(E/system/apps)，覆盖即可。十二、网络1. 设置接入点 设置方法：设置 — 连接设置 — 接入点 — 选项 — 新增接入点 — 使用默认连接，设置如下： 连接名称：中国移动彩信（GPRS） 数据承载方式： GPRS
接入点名称： cmnet 用户名：无 提示输入密码：否 　密码：无 鉴定：普通 主页：/ 设置彩信设置方法：信息 — 选项 — 设置 — 彩信，设置如下：接入点：中国移动彩信（GPRS）彩信接受：始终打开允许匿名：是接受广告：是接受报告：是有效期：最长时间2. 设置邮箱 设置方法：信息 — 选项 — 设置 — 电子邮件 — 信箱 — 选项 — 新信箱，设置如下： 信箱名称：由用户自定义 使用的接入点：第一步中用户自己设置的接入点 我的电子邮件地址：用户自己的邮箱地址 邮件发送服务器：由邮箱网站提供（此处以网易为例： ） 发送信息：立即发送 给自己发送副本：否 包括签名：否 用户名：本人邮箱的用户名 密码：邮箱密码 邮件接收服务器：由邮箱网站提供（此处以网易新浪为例：
） 信箱类型： POP3 安全保护：关 APOP 安全登录：关 使用中的邮箱：信息 — 选项 — 设置 — 电子邮件 — 使用中的邮箱 — 选择用于发送邮件的邮箱，当有多个邮箱时会有多个选项。 建立设置好邮箱后，打开功能表 — 信息 — 在菜单下会出现你所设置好的邮箱名称. 3. 收发邮件 1)收邮件 功能表 — 信息 — 找到你设置的邮箱 — 进入，系统会提示是否连接到信箱，选择“是”后，便会通过设置好的接入点，连接到你的信箱 进入信箱后按“选项” — 提取电子邮件，可选择提取新信息或所有信息 当选择连接信箱后，会收取信箱中的未读或所有邮件，还需要选中要提取的邮件进行提取，提取过的邮件，前面的图标会变成灰色，且箭头朝里，如果还没提取过，则前面的图标为彩色，且箭头朝外 2)发邮件 功能表 — 信息 — 找到你设置的邮箱 — 进入，打开选项 — 写信息 — 电子邮件，则出现界面， 写好收件人和抄送人及主题后，下面就可以写正文了，可以选择插入附件（方法：在写邮件界面下按选项 — 插入 — 选择要插入的附件，包括图像、声音片段、视频片段、笔记、常用短语），当插入附件后，在上面的状态栏上会有附件的图标， 你也可以通过在写邮件界面下按选项 — 附件 — 进行查看附件， 当正文、附件全都写好后，就可以按选项 — 发送，系统会自动按照你选设置的接入点进行连接 GPRS 进行发送。
如果您想提高自己的技术水平，欢迎加入本站官方1号QQ群：&&，&&2号QQ群：，在群里结识技术精英和交流技术^_^
本站联系邮箱：