精华内容
下载资源
问答
  • WAS控制台数据源信息无故丢失,但应用程序可以正常启动,查看resource.xml 可以查看到对应jdbc 信息,因数据源中有中文,xml显示是乱码,但控制台确找不到对应设置信息。 解决办法: 采用...

    问题描述:
    WAS控制台数据源信息无故丢失,但应用程序可以正常启动,查看resource.xml 可以查看到对应的jdbc 信息,因数据源中有中文,xml显示是乱码,但控制台确找不到对应的设置信息。
    解决办法:
    采用初始化的方式恢复was 控制台数据源显示方式:
    1.dmgr node  server1 全部停止掉
    2.删除profiles/dmgr01/logs/下面的所有日志信息
    /logs/dmgr/
    /losg/ffdc/
    3.删除profiles/AppSrv01/logs/下面的所有日志信息
    /logs/server1/
    /logs/nodeagent/
    /logs/ffdc/
    4.删除如下目录文件
    profiles\dmgr\wstemp 下的所有文件与目录
    profiles\dmgr\temp 下的所有文件与目录
    5. 执行如下命令
    profiles\AppSrv01\bin\ ./iscdeploy.sh -restore
    以上命令操作必须在 dm node server1 停止工作状态操作
    6. 重启dm node server1

    这样就可以看到数据源已恢复显示了

    来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/29960155/viewspace-1369710/,如需转载,请注明出处,否则将追究法律责任。

    转载于:http://blog.itpub.net/29960155/viewspace-1369710/

    展开全文
  • 远程数据源应用于正式环境有一段时间了。期间未收到bug提交。 查看了从6月2日-6月12日日志,发现两种error错误。经调查这两种错误都是由于业务逻辑错误造成,和数据源无关。(意外收获,还能检查逻辑漏洞) ...
    问题的由来和分析,请看http://mazhen2010.iteye.com/blog/654366

    远程数据源应用于正式环境有一段时间了。期间未收到bug提交。
    查看了从6月2日-6月12日的日志,发现两种error错误。经调查这两种错误都是由于业务逻辑错误造成的,和数据源无关。(意外收获,还能检查逻辑漏洞)
    学习了微软的was性能测试工具,想做个全面的性能测试。

    以TTLB Avg为参考值,远程数据源相较普通方式性能提升18.11%
    5分钟内点击量增加271次,每秒连接数增加0.91次
    名词解释:TTFB Avg:从第一个请求发出到测试工具接收到服务器应答数据的第一个字节之间的平均时间。
    TTLB Avg:从第一个请求发出到测试工具接收到服务器应答数据的最后一个字节之间的平均时间

    [b]虽然应用到了实际项目中,但这个项目pv不是很高。现在不太敢用到大型项目中,把服务端代码公布出来,如果有兴趣,可以看看,帮我找找问题,共同探讨。[/b]

    [b]为每个proxool别名创建一个对象,并保存在内存中[/b]
    import java.rmi.RemoteException;
    import java.rmi.server.UnicastRemoteObject;
    import java.util.Hashtable;

    import org.apache.log4j.Logger;
    import org.logicalcobwebs.proxool.ProxoolFacade;

    public class ConnectionFactoryPools extends UnicastRemoteObject implements Factory {

    /**
    *
    */
    private static final long serialVersionUID = -9094038611699927527L;
    private static Logger log = Logger.getLogger(ConnectionFactoryPools.class);
    private static Hashtable<String, ConnectionFactory> factoryPools = null;
    static {
    String[] aliases = ProxoolFacade.getAliases();
    if (aliases.length > 0) {
    factoryPools = new Hashtable<String, ConnectionFactory>();
    for (int i = 0; i < aliases.length; i++) {
    ConnectionFactory factory = new ConnectionFactory(aliases[i]);
    factoryPools.put(aliases[i], factory);
    }

    }
    }

    public ConnectionFactoryPools() throws RemoteException {}

    public String authenticateAlias(ConnectionParam param) throws RemoteException {

    log.info("Authenticate alias=" + param.getAlias());
    String aliasKey = "90";
    if (factoryPools != null && param.getAlias() != null) {
    ConnectionFactory factory = factoryPools.get(param.getAlias());
    if (factory != null) {
    int flag = factory.checkConConfig(param);
    if (flag == 0) {
    aliasKey = factory.toString();
    }
    } else {
    aliasKey = "91";
    }
    }
    return aliasKey;
    }

    /**
    * <p>Title: createQueryConnection</p>
    * <p>Description: 创建查询的connection环境</p>
    * @author mazhen
    * @return 0:参数正常 1:参数不全 2: 连接池中没有数据源
    * 3:用户名错误 4:密码错误 5:没有指定别名的数据源
    * 90:工厂池为空 91:指定的数据库别名没有工厂对象 99:异常
    */
    public String createQueryConnection(String alias, String aliasKey, String sql) throws RemoteException {

    String conKey = "90";
    if (factoryPools != null && aliasKey != null && alias != null) {
    ConnectionFactory factory = factoryPools.get(alias);
    if (factory != null && aliasKey.equals(factory.toString())) {
    conKey = factory.createQueryConnection(sql);
    } else {
    conKey = "91";
    }
    }
    return conKey;
    }

    /**
    * <p>Title: createQueryConnection</p>
    * <p>Description: 创建查询的connection环境</p>
    * @author mazhen
    * @return 0:参数正常 1:参数不全 2: 连接池中没有数据源
    * 3:用户名错误 4:密码错误 5:没有指定别名的数据源
    * 90:工厂池为空 91:指定的数据库别名没有工厂对象 99:异常
    */
    public String createQueryConnection(ConnectionParam param, String sql) throws RemoteException {

    String conKey = "90";
    if (factoryPools != null && param.getAlias() != null) {
    ConnectionFactory factory = factoryPools.get(param.getAlias());
    if (factory != null) {
    conKey = factory.createQueryConnection(param, sql);
    } else {
    conKey = "91";
    }
    }
    return conKey;
    }

    public void releaseQueryConnection(String alias, String conKey) throws RemoteException {

    MConnection con = (MConnection) NamingManager.lookup(conKey);
    boolean flag = false;
    if (factoryPools != null && alias != null) {
    ConnectionFactory factory = factoryPools.get(alias);
    if (factory != null) {
    flag = factory.activateConnectionInPools(con.getSql());
    }
    }
    //工厂激活链接失败,则强制关闭链接
    if (flag == false) {
    con.releaseQueryConfig();
    }
    }

    /**
    * <p>Title: createProcedureConnection</p>
    * <p>Description: 创建存储过程的connection环境</p>
    * @author mazhen
    * @return 0:参数正常 1:参数不全 2: 连接池中没有数据源
    * 3:用户名错误 4:密码错误 5:没有指定别名的数据源
    * 90:工厂池为空 91:指定的数据库别名没有工厂对象 99:异常
    */
    public String createProcedureConnection(ConnectionParam param, String procedure) throws RemoteException {
    String conKey = "90";
    if (factoryPools != null && param.getAlias() != null) {
    ConnectionFactory factory = factoryPools.get(param.getAlias());
    if (factory != null) {
    conKey = factory.createProcedureConnection(param, procedure);
    } else {
    conKey = "91";
    }
    }
    return conKey;
    }
    }

    [b]
    proxool别名工厂,创建链接和释放。会缓存常用sql的链接,以提升效率[/b]

    import java.rmi.RemoteException;
    import java.sql.CallableStatement;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.util.Hashtable;
    import java.util.Iterator;
    import java.util.Properties;
    import java.util.Map.Entry;
    import java.lang.ClassNotFoundException;

    import org.apache.log4j.Logger;
    import org.logicalcobwebs.proxool.ConnectionPoolDefinitionIF;
    import org.logicalcobwebs.proxool.ProxoolFacade;

    import com.changyou.proxool.PBEStringDecryptor;

    public class ConnectionFactory {

    //private boolean isEncrypt = true; //Is password been encrypted?
    private int maxCount = 2; //use proxool's MinimumConnectionCount
    private String alias = null;
    private String user = null;
    private String password = null;
    private static Hashtable<String, MConnectionVo> connectionPools = null;

    private static Logger log = Logger.getLogger(ConnectionFactory.class);

    public ConnectionFactory(String alias) {

    log.info("Initialising data source '" + alias + "' start.");
    try {
    ConnectionPoolDefinitionIF def = ProxoolFacade.getConnectionPoolDefinition(alias);
    maxCount = def.getMinimumConnectionCount();

    Properties p = def.getDelegateProperties();
    Iterator j = p.keySet().iterator();
    while (j.hasNext()) {
    String name = (String)j.next();
    String value = p.getProperty(name);
    //比较用户名
    if ((name.toLowerCase().indexOf("user") > -1)) {
    this.user = value;
    }
    //比较密码
    if ((name.toLowerCase().indexOf("password") > -1)
    || (name.toLowerCase().indexOf("passwd") > -1)) {
    this.password = value;
    }
    }

    this.alias = alias;
    log.info("Initialising data source '" + alias + "' success.");
    } catch(Exception e) {
    maxCount = 2;
    alias = null;
    user = null;
    password = null;
    log.error("Initialising data source '" + alias + "' failed.");
    log.error(e.toString());
    }
    connectionPools = new Hashtable<String, MConnectionVo>();
    }
    /**
    * <p>Title: createQuerySource</p>
    * <p>Description: 利用sql创建数据库链接和preparedStatement</p>
    * @author mazhen
    * @param sql
    * @return 0:参数正常 1:参数不全 2: 连接池中没有数据源
    * 3:用户名错误 4:密码错误 5:没有指定别名的数据源 99:异常
    */
    public synchronized String createQueryConnection(ConnectionParam param, String sql) {

    String conKey = "99";
    int flag = checkConConfig(param);
    if (flag == 0) {
    //首先看看常用sql的链接池中是否有这个sql的链接
    String hasCon = getConnectionFromPools(sql);
    if (hasCon != null) {
    //如果池中有此sql链接,则直接掉用池中的链接
    conKey = hasCon;
    } else {
    //没有链接或者链接被占用
    try {
    Connection connection = DriverManager.getConnection("proxool." + alias);
    PreparedStatement statement = connection.prepareStatement(sql);
    MConnection mcon = new MConnectionImpl(connection, statement);
    mcon.setSql(sql);
    conKey = mcon.toString();
    NamingManager.bind(conKey, mcon);
    //如果池中没有此sql的链接,则添加一个,如果有则重置最后访问时间
    addConnectionToPools(sql, mcon);

    } catch (Exception e) {
    log.error("Created query connection with user and password!alias=" + alias);
    log.error("sql=" + sql);
    log.error(e.toString());
    }
    }


    } else {
    conKey = new Integer(flag).toString();
    }
    return conKey;
    }

    public synchronized String createQueryConnection(String sql) {

    String conKey = "99";

    //首先看看常用sql的链接池中是否有这个sql的链接
    String hasCon = getConnectionFromPools(sql);
    if (hasCon != null) {
    //如果池中有此sql链接,则直接掉用池中的链接
    conKey = hasCon;
    } else {
    //没有链接或者链接被占用
    try {
    Connection connection = DriverManager.getConnection("proxool." + alias);
    PreparedStatement statement = connection.prepareStatement(sql);
    MConnection mcon = new MConnectionImpl(connection, statement);
    mcon.setSql(sql);
    conKey = mcon.toString();
    NamingManager.bind(conKey, mcon);
    //如果池中没有此sql的链接,则添加一个,如果有则重置最后访问时间
    addConnectionToPools(sql, mcon);

    } catch (Exception e) {
    log.error("Created query connection without user and password!alias=" + this.alias);
    log.error("sql=" + sql);
    log.error(e.toString());
    }
    }
    return conKey;
    }

    /**
    * <p>Title: createProcedureConnection</p>
    * <p>Description: 检查数据库链接别名,用户名,密码是否正确</p>
    * @author mazhen
    * @param procedure
    * @return 0:参数正常 1:参数不全 2: 连接池中没有数据源
    * 3:用户名错误 4:密码错误 5:没有指定别名的数据源 99:异常
    */
    public synchronized String createProcedureConnection(ConnectionParam param, String sql) {

    String conKey = "99";
    int flag = checkConConfig(param);
    if (flag == 0) {
    //首先看看常用sql的链接池中是否有这个sql的链接
    String hasCon = getConnectionFromPools(sql);
    if (hasCon != null) {
    //如果池中有此sql链接,则直接掉用池中的链接
    conKey = hasCon;
    } else {
    //没有链接或者链接被占用
    try {
    Connection connection = DriverManager.getConnection("proxool." + alias);
    CallableStatement statement = connection.prepareCall(sql);
    MConnection mcon = new MConnectionImpl(connection, statement);
    mcon.setSql(sql);
    conKey = mcon.toString();
    NamingManager.bind(conKey, mcon);
    //如果池中没有此sql的链接,则添加一个,如果有则重置最后访问时间
    addConnectionToPools(sql, mcon);

    } catch (Exception e) {
    log.error("Created Procedure connection with user and password!alias=" + alias);
    log.error("sql=" + sql);
    log.error(e.toString());
    }
    }


    } else {
    conKey = new Integer(flag).toString();
    }
    return conKey;
    }

    public synchronized String createProcedureConnection(String sql) {

    String conKey = "99";

    //首先看看常用sql的链接池中是否有这个sql的链接
    String hasCon = getConnectionFromPools(sql);
    if (hasCon != null) {
    //如果池中有此sql链接,则直接掉用池中的链接
    conKey = hasCon;
    } else {
    //没有链接或者链接被占用
    try {
    Connection connection = DriverManager.getConnection("proxool." + alias);
    CallableStatement statement = connection.prepareCall(sql);
    MConnection mcon = new MConnectionImpl(connection, statement);
    mcon.setSql(sql);
    conKey = mcon.toString();
    NamingManager.bind(conKey, mcon);
    //如果池中没有此sql的链接,则添加一个,如果有则重置最后访问时间
    addConnectionToPools(sql, mcon);

    } catch (Exception e) {
    log.error("Created Procedure connection without user and password!alias=" + this.alias);
    log.error("sql=" + sql);
    log.error(e.toString());
    }
    }
    return conKey;
    }

    /**
    * <p>Title: checkConConfig</p>
    * <p>Description: 检查数据库链接别名,用户名,密码是否正确</p>
    * @author mazhen
    * @return 0:参数正常 1:参数不全 2: 连接池中没有数据源
    * 3:用户名错误 4:密码错误 5:没有指定别名的数据源 99:异常
    */
    public int checkConConfig(ConnectionParam param) {
    int flag = 99;
    if (param.getAlias() == null || param.getUser() == null || param.getPassword() == null) {
    //1:参数不全
    flag = 1;
    } else {
    if (param.getAlias().equals(this.alias) && user != null && password != null) {

    //比较用户名
    if (param.getUser().equals(user) == false) {
    //3:用户名错误
    flag = 3;
    }

    //比较密码
    String dePassword = param.getPassword();
    try {
    //利用了运行时异常和编译时异常,在有PBEStringEncryptor时,则解密
    //没有PBEStringEncryptor这个接口时,虽然PBEStringDecryptor编译错误,但是当前工厂可以编译通过,且不走PBEStringDecryptor的分支
    if (Class.forName("org.jasypt.encryption.pbe.PBEStringEncryptor").isInterface() == true) {
    dePassword = PBEStringDecryptor.decrypt(dePassword);
    if (dePassword == null) {
    dePassword = param.getPassword();
    }
    }
    } catch (ClassNotFoundException c) {
    log.info("Don't need decrypt! alias=" + param.getAlias());
    } catch (Exception e) {
    log.error("PBEStringEncryptor decrypt password faild! alias=" + param.getAlias());
    log.error(e.toString());
    }
    if (password.equals(dePassword) == false) {
    //4:密码错误
    flag = 4;
    }

    //0:参数正确
    if (flag != 3 && flag != 4) {
    flag = 0;
    }
    }
    }
    return flag;
    }

    /**
    * <p>Title: getConnectionFromPools</p>
    * <p>Description: 查找连接池中是否存在此sql的链接</p>
    * @author mazhen
    * @return null:连接池中没有此sql的链接 con:连接的字符串
    */
    private String getConnectionFromPools(String sql) {
    String returnValue = null;
    MConnectionVo vo = connectionPools.get(sql);
    if (vo != null) {

    //验证此链接是否还活着?
    try {
    if (vo.getCon().checkClose() == false) {
    if (vo.isUsing() == false) {
    vo.setUsing(true);
    vo.setLastUsedTime(System.currentTimeMillis());
    returnValue = vo.getCon().toString();
    }
    } else {
    connectionPools.remove(sql);
    }
    } catch(RemoteException e) {
    connectionPools.remove(sql);
    log.error("Check connection is openning faild!alias=" + this.alias);
    log.error("sql=" + sql);
    log.error(e.toString());
    }

    }
    return returnValue;
    }

    /**
    * <p>Title: addConnectionToPools</p>
    * <p>Description: 向连接池中添加链接</p>
    * @author mazhen
    */
    private void addConnectionToPools(String sql, MConnection con) {
    //如果此sql对应的链接在池中存在
    MConnectionVo vo = connectionPools.get(sql);
    if (vo != null) {
    vo.setLastUsedTime(System.currentTimeMillis());
    return;
    }

    if (connectionPools.size() < this.maxCount) {
    vo = new MConnectionVo();
    vo.setCon(con);
    connectionPools.put(sql, vo);
    } else {

    //找到访问时间最久远的sql
    Iterator it = connectionPools.entrySet().iterator();
    String lastUsedSql = null;
    long lastUsedTime = System.currentTimeMillis();
    while (it.hasNext()) {
    Entry<String, MConnectionVo> entry = (Entry) it.next();
    MConnectionVo value = entry.getValue();
    if (lastUsedTime > value.getLastUsedTime()) {
    lastUsedTime = value.getLastUsedTime();
    lastUsedSql = entry.getKey();
    }
    }

    //release last connection
    try {
    vo = connectionPools.get(lastUsedSql);
    vo.getCon().releaseQueryConfig();
    vo.getCon().releaseProcedureConfig();
    vo = null;
    } catch(Exception e) {
    log.error("Release last connection faild!sql=" + sql);
    } finally {
    vo = null;
    }

    vo = new MConnectionVo();
    vo.setCon(con);
    connectionPools.remove(lastUsedSql);
    connectionPools.put(sql, vo);

    }
    }

    /**
    * <p>Title: activateConnectionInPools</p>
    * <p>Description: 激活链接,供下次访问使用</p>
    * @author mazhen
    * @return true:激活成功 false:激活失败
    */
    public boolean activateConnectionInPools(String sql) {
    boolean returnValue = false;
    MConnectionVo vo = connectionPools.get(sql);
    if (vo != null) {
    vo.setUsing(false);
    returnValue = true;
    }
    return returnValue;
    }
    }

    [b]链接对象,处理数据库操作[/b]

    import java.rmi.server.UnicastRemoteObject;
    import java.rmi.RemoteException;
    import java.sql.Connection;
    import java.sql.Date;
    import java.sql.PreparedStatement;
    import java.sql.CallableStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.Collection;
    import java.util.Vector;
    import java.util.HashMap;
    import java.sql.ResultSetMetaData;
    import java.sql.Types;

    import javax.sql.rowset.CachedRowSet;

    import org.apache.log4j.Logger;

    //import com.sun.rowset.CachedRowSetImpl;
    //import com.sun.rowset.internal.Row;

    public class MConnectionImpl extends UnicastRemoteObject implements MConnection {

    /**
    *
    */
    private static final long serialVersionUID = -2338044775116389138L;
    private String sql = null;
    private static Logger log = Logger.getLogger(MConnectionImpl.class);

    public MConnectionImpl(Connection con, PreparedStatement statement) throws RemoteException {
    this.connection = con;
    this.preparedStatement = statement;
    }

    public MConnectionImpl(Connection con, CallableStatement statement) throws RemoteException {
    this.connection = con;
    this.callableStatement = statement;
    }

    private Connection connection = null;
    private PreparedStatement preparedStatement = null;
    private CallableStatement callableStatement = null;
    private ResultSet resultSet = null;
    private CachedRowSet rowSet = null;

    public void releaseQueryConfig() throws RemoteException {
    try {
    if (connection != null) {
    NamingManager.unbind(this.toString());
    connection.close();
    }
    if (preparedStatement != null) {
    preparedStatement.close();
    }
    if (resultSet != null) {
    resultSet.close();
    }
    } catch(Exception e) {
    log.error("Sql=" + sql);
    log.error(e.toString());
    }
    }

    public void releaseProcedureConfig() throws RemoteException {
    try {
    if (connection != null) {
    NamingManager.unbind(this.toString());
    connection.close();
    }
    if (callableStatement != null) {
    callableStatement.close();
    }
    } catch(Exception e) {
    log.error("Sql=" + sql);
    log.error(e.toString());
    }
    }

    public void setStringPreparedSmt(int index, String parameter) throws RemoteException {
    try {
    if (this.preparedStatement != null) {
    this.preparedStatement.setString(index, parameter);
    }
    } catch (Exception e) {
    log.error("Sql=" + sql);
    log.error(e.toString());
    }

    }

    public void setIntPreparedSmt(int index, int parameter) throws RemoteException {
    try {
    if (this.preparedStatement != null) {
    this.preparedStatement.setInt(index, parameter);
    }
    } catch (Exception e) {
    log.error("Sql=" + sql);
    log.error(e.toString());
    }

    }

    public void setDatePreparedSmt(int index, Date parameter) throws RemoteException {
    try {
    if (this.preparedStatement != null) {
    this.preparedStatement.setDate(index, parameter);
    }
    } catch (Exception e) {
    log.error("Sql=" + sql);
    log.error(e.toString());
    }

    }

    public void execPreparedSmt() throws RemoteException {
    try {
    //long st_temp = System.currentTimeMillis();
    this.resultSet = this.preparedStatement.executeQuery();
    //long end_temp = System.currentTimeMillis();
    //System.out.println("execute used "+(end_temp - st_temp));
    } catch(Exception e) {
    log.error("Sql=" + sql);
    log.error(e.toString());
    }
    }

    public int execPreparedSmtForUpdate() throws RemoteException {
    int returnValue = -1;
    try {
    //long st_temp = System.currentTimeMillis();
    returnValue = this.preparedStatement.executeUpdate();
    //long end_temp = System.currentTimeMillis();
    //System.out.println("execute used "+(end_temp - st_temp));
    } catch(Exception e) {
    log.error("Sql=" + sql);
    log.error(e.toString());
    }
    return returnValue;
    }

    // public void setStringCallableSmt(int index, String parameter) throws RemoteException {
    // try {
    // if (this.callableStatement != null) {
    // this.callableStatement.setString(index, parameter);
    // }
    // } catch (Exception e) {
    // e.printStackTrace();
    // }
    //
    // }
    //
    // public void execCallableSmt() throws RemoteException {
    // try {
    // this.resultSet = this.preparedStatement.executeQuery();
    // } catch(Exception e) {
    // e.printStackTrace();
    // }
    // }

    public String getStringResult(String column) throws RemoteException {
    String returnValue = null;
    try {
    if (this.resultSet.next()) {
    returnValue = this.resultSet.getString(column);
    }
    } catch(SQLException e) {
    log.error("Sql=" + sql);
    log.error(e.toString());
    }
    return returnValue;
    }

    public int getIntResult(String column) throws RemoteException {
    int returnValue = -1;
    try {
    if (this.resultSet.next()) {
    returnValue = this.resultSet.getInt(column);
    }
    } catch(SQLException e) {
    log.error("Sql=" + sql);
    log.error(e.toString());
    }
    return returnValue;
    }

    public Collection getResultSet() throws RemoteException {

    Vector returnValue = new Vector();
    try {
    ResultSetMetaData meta = resultSet.getMetaData();
    String name = null;
    while (resultSet.next()) {
    java.util.Map row = new HashMap();
    for (int column = 1; column <= meta.getColumnCount(); column++) {
    int type = meta.getColumnType(column);
    name = meta.getColumnName(column);
    //System.out.println(name+"/"+type);
    if (Types.CHAR == type || Types.VARCHAR == type
    || Types.CLOB == type) {
    String value = resultSet.getString(column);
    row.put(name, value);
    } else if (Types.INTEGER == type || Types.TINYINT == type
    || Types.NUMERIC == type) {
    int value = resultSet.getInt(column);
    row.put(name, value);
    } else if (Types.DATE == type || Types.TIME == type
    || Types.TIMESTAMP == type) {
    java.util.Date value = resultSet.getDate(column);
    row.put(name, value);
    }

    }
    returnValue.add(row);
    }
    } catch(Exception e) {
    log.error("Sql=" + sql);
    log.error(e.toString());
    }
    return returnValue;
    }

    public String getSql() throws RemoteException {
    return sql;
    }

    public void setSql(String sql) throws RemoteException {
    this.sql = sql;
    }

    public boolean checkClose() throws RemoteException {
    boolean flag = true;
    try {
    flag = this.connection.isClosed();
    } catch(SQLException e) {
    log.error("Sql=" + sql);
    log.error(e.toString());
    }
    return flag;
    }
    }

    主要就是这3个类,其他还有些接口就不放上来了。
    展开全文
  • was性能调优

    2015-04-08 21:10:00
    数据库设置 使用此页面来指定数据库会话支持的设置。 要查看此管理控制台页面,请单击服务器 > 服务器类型 > WebSphere 应用程序服务器 >...非 XA 启用的数据源的 JNDI 名称,会话管理功能从...

    数据库设置

    使用此页面来指定数据库会话支持的设置。

    要查看此管理控制台页面,请单击服务器 > 服务器类型 > WebSphere 应用程序服务器 > server_name > 会话管理 > 分布式环境设置 > 数据库。

    “配置”选项卡

    数据源 JNDI 名称

    指定数据源描述。

    非 XA 启用的数据源的 JNDI 名称,会话管理功能从该数据源中获取数据库连接。例如,如果数据源的 JNDI 名称为“jdbc/sessions”,那么指定“jdbc/sessions”。数据源提供数据库连接池以及该池的配置(例如池大小)。数据源必须作为环境中已配置的资源存在。

    DB2 行大小 

    如果使用 DB2® 数据库,那么指定为会话表配置的表空间页大小。可能的值为 4、8、16 或 32 千字节(KB)。缺省行大小为 4KB。

    缺省行大小为 4KB。在 DB2 中,可以将它更新为更大的值。在某些环境中,这可以有助于数据库性能的发挥。当该值不是 4 时,您必须指定表空间名称以使用该属性。对于 4KB 页面,表空间名称是可选的。

    表空间名称 

    指定会话表使用的表空间。

    当 DB2 页大小不是 4 KB 时需要该值。

    使用多行模式

    指定将每个会话数据属性放入数据库中的单独一行,从而允许为每个会话存储更多的数据。当会话属性非常大,而需要对会话属性进行的更改很少时,此操作将获得更好的性能。如果未启用使用多行模式,那么应用程序数据的实例可放在同一行中。

    调整参数设置

    使用此页为分布式会话设置调整参数。

    要查看此管理控制台页面,请单击服务器 > 服务器类型 > WebSphere 应用程序服务器 > server_name > 会话管理 > 分布式环境设置 > 定制调整参数。

    “配置”选项卡

    调整级别

    指定会话管理设施提供影响性能的某些预定义设置。

    从这些预定义设置中选择一个设置,或定制一个设置。要定制设置,选择一个与期望的设置最接近的预定义设置,单击定制设置,进行更改,然后单击确定

    TCP 传输通道设置

    应用程序服务器 > server1 > 传输链 > SIPCInboundDefault > TCP 入站通道(TCP_8)

    使用此页面来配置入站网络流量的 TCP 入站通道。

    不活动超时

    以秒为单位指定时间量,TCP 传输通道在这段时间内等待套接字上的读或写请求完成。

    如果关闭客户机连接前未能及时地将数据写回到客户机,那么,请更改“不活动超时”参数值。此参数控制可供服务器使用的最大连接数。接收到新连接后,TCP 传输通道先等待足够的数据到达,然后再将该连接分派给 TCP 传输通道上特定于协议的通道。如果在对“不活动超时”参数指定的时间段内未接收到足够的数据,TCP 传输通道就会关闭该连接。

    此参数的缺省值是 60 秒,它适合于大多数应用程序。如果工作负载涉及大量的连接,并且所有这些连接都无法在 60 秒内接受服务,那么应该增大对此参数指定的值。

     避免故障: 为此属性指定的值可由此通道上面的通道建立的等待时间覆盖。例如,为 HTTP 传输通道建立的等待时间覆盖为除新的套接字上的初始读之外的每个操作的该属性指定的值。 
    线程池 

    此字段仅适用于 i5/OS 和分布式平台。从可用的线程池的下拉列表中选择您希望 TCP 传输通道在分派工作时使用的线程池。

     在 z/OS 平台上,此字段不适用于作为 Web 容器传输链成员的 TCP 通道。这些 TCP 通道是通过特殊的内部线程池工作的,以便最大程度地减少线程上下文切换并提高性能。

    排除地址列表

    列出不允许进行入站连接的 IP 地址。

    使用逗号分隔您要拒绝对入站 TCP 连接请求的访问权的 IPv4 和/或 IPv6 地址。

    IPv4 地址中的所有四个数字值都必须用数字或通配符 *(星号)表示。

    以下是可包括在“排除地址列表”中的有效 IPv4 地址的示例:
    *.1.255.0
    254.*.*.9
    1.*.*.*
    

    包括主机名列表

    列出允许进行入站连接的主机名。使用逗号分隔您要授权给它对入站 TCP 连接请求的访问权的 URL 地址。

    URL 地址可以通配符 *(星号)开头,后跟一个句点;例如,*.Rest.Of.Address。如果通配符后面没有句点,那么星号将被视为常规的非通配符。通配符不能在地址中的任何其他位置出现。例如,ibm.*.com不是有效的主机名。

    以下是可包括在包括主机名列表中的有效 URL 地址的示例:
    *.ibm.com
    www.ibm.com
    *.com

    线程池集合

    使用此页面来查看和管理应用程序服务器使用的线程池。线程池使服务器的组件能够重复使用线程,从而不必在运行时创建新线程。创建新的线程将耗费时间和资源。

     注: 对于 z/OS 平台,此页面不可用,因为在 z/OS 环境中不使用线程池。Z/OS是IBM的一款os

    要查看此管理控制台页面,可以选择多个导航路径。例如,单击服务器 > 服务器类型 > WebSphere 应用程序服务器 > 服务器 > 线程池。

    要查看特定线程池的设置,请单击该线程池的名称。

    要创建线程池,请单击新建,然后在生成的面板上输入信息。

    要删除线程池,请选择要删除的线程池,然后单击删除







    转载于:https://www.cnblogs.com/shareyezi/p/4109238.html

    展开全文
  • 查看了一下数据源及共享库引用问题 根据具体堆栈查看了一下spring-jdbc源码 把原来引用OracleLobHandler改为DefaultLobHandler,应用引用是spring-jdbc3.2.13版本,...

    在部署应用环境时,应用进行clob字段的保存时这个问题


    先查看了一下数据源及共享库的引用问题




    根据具体堆栈查看了一下spring-jdbc的源码



    把原来引用的OracleLobHandler改为DefaultLobHandler,应用引用的是spring-jdbc3.2.13版本,OracleLobHandler已经Deprecated了

    lobHandler=org.springframework.jdbc.support.lob.DefaultLobHandler

    重启一下应用,问题解决!
    展开全文
  • SessionStorage 存储的数据只在会话期间有效,关闭浏览器则自动删除 Sqlite 一款轻型的数据库,是遵守ACID的关系型数据库管理系统,它包含在一个相对小的C库中 W3C 万维网联盟,创建于1994年,是Web技术领域最具权威...
  • 可使用平台提供共享集群,也可为应用申请独立集群 Topic 申 请 :可根据应用(App)创建Topic,或者申请其他topic读写权限 Topic 运 维 :Topic数据采样、调整配额、申请分区等操作 指 标 监 控 :...
  • C#是编写.NET应用程序一种语言,本书适合于希望提高编程技巧、有经验C#程序员,也适用于刚开始使用C#专业开发人员。本书探讨了Visual Studio 2013和.NET Framework 4.5.1、新测试驱动开发和并发编程功能。...
  • C#是编写.NET应用程序一种语言,本书适合于希望提高编程技巧、有经验C#程序员,也适用于刚开始使用C#专业开发人员。本书探讨了Visual Studio 2013和.NET Framework 4.5.1、新测试驱动开发和并发编程功能。...
  • C#是编写.NET应用程序一种语言,本书适合于希望提高编程技巧、有经验C#程序员,也适用于刚开始使用C#专业开发人员。本书探讨了Visual Studio 2013和.NET Framework 4.5.1、新测试驱动开发和并发编程功能。...
  • 6.5 用户定义的数据类型转换 6.5.1 执行用户定义的类型转换 6.5.2 多重数据类型转换 6.6 小结 第7章 委托和事件 7.1 委托 7.1.1 在C#中声明委托 7.1.2 在C#中使用委托 7.1.3 简单的委托示例 7.1.4 BubbleSorter示例 ...
  • 6.5 用户定义的数据类型转换 6.5.1 执行用户定义的类型转换 6.5.2 多重数据类型转换 6.6 小结 第7章 委托和事件 7.1 委托 7.1.1 在C#中声明委托 7.1.2 在C#中使用委托 7.1.3 简单的委托示例 7.1.4 BubbleSorter示例 ...
  • 定义 数组是一种排列有序的数据结构,包含于数组中的变量被称为数组的元素, 它们都有相同的类型。 数组声明 int [] array1 = new int[5]; int [,,] array3 = new int[10,20,30]; int [] array1 = new int[] {1,2,4}...
  • C#高级编程(第6版)

    2011-05-11 11:10:30
     6.5 用户定义的数据类型转换  6.5.1 执行用户定义的类型转换  6.5.2 多重数据类型转换  6.6 小结  第7章 委托和事件  7.1 委托  7.1.1 在C#中声明委托  7.1.2 在C#中使用委托  7.1.3 简单的委托示例  ...
  •  6.5 用户定义的数据类型转换  6.5.1 执行用户定义的类型转换  6.5.2 多重数据类型转换  6.6 小结  第7章 委托和事件  7.1 委托  7.1.1 在C#中声明委托  7.1.2 在C#中使用委托  7.1.3 简单的委托示例  ...
  • 2009达内SQL学习笔记

    2010-02-10 19:46:58
    检索返回数据的顺序没有特殊意义,为了明确地排序用 SELECT 语句检索出的数据,可使用 ORDER BY 子句。 ORDER BY 子句取一个或多个列的名字。 对空值,按无穷大处理(升序中,空值排最后;降序中排最前)。 1、...
  • #数据源 spring.datasource.url=jdbc:mysql://localhost:3306/tourismPro?useUnicode=true&zeroDateTimeBehavior=convertToNull&autoReconnect=true&characterEncoding=utf8 spring.datasource.username...
  • arcgis工具

    2012-10-22 22:37:31
    对于基于文件的数据源,例如shape文件或coverages,既可以使用UPPER函数,也可以使用LOWER函数。 例如下面这个查询将选出那些姓名的最后为Jones或JONES的顾客。 UPPER("LAST_NAME") = 'JONES' 可以用LIKE运算符...
  • 该qjscalc应用程序是qjsbn命令行解释器超集,它实现了一个具有任意大整数和浮点数,分数,复数,多项式和矩阵Javascript计算器。代码在qjscalc.js中。http://numcalc.com上提供了更多文档和Web版本。 2.5 ...
  • springmybatis

    2015-09-05 06:54:28
    查询出列表,也就是返回list, 在我们这个例子中也就是 List<User> , 这种方式返回数据,需要在User.xml 里面配置返回类型 resultMap, 注意不是 resultType, 而这个resultMap 所对应应该是我们自己配置 ...
  • CISCO 技术大集合

    2013-05-22 01:07:13
    以下在Router1上设置了访问192.1.0.64/26这个网下一跳地址为192.200.10.6,即当有目的地址属于192.1.0.64/26的网络范围的数据报,应将其路由到地址为192.200.10.6的相邻路由器。在Router3上设置了访问192.1.0.128/26...
  • 特色HTML框架可以创建精美iOS应用 http://framework7.taobao.org 淘宝SUI http://m.sui.taobao.org avalon 地址 avalonjs http://avalonjs.github.io Avalon新一代UI库: OniUI ...

空空如也

空空如也

1 2
收藏数 21
精华内容 8
关键字:

was查看应用的数据源