Android Studio使用JDBC远程连接mysql的注意事项（附示例）
时间： 18:24:38
&&&& 阅读：4804
&&&& 评论：
&&&& 收藏：0
标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&JDBC为java程序访问各种类型的关系型数据库提供了统一的接口，用户不必针对不同数据库写出不同的代码，但是使用JDBC必须得下载相应的驱动，比如我这里是要连接mysql，于是就到mysql官网去下载x相应驱动&https://dev.mysql.com/downloads/connector/j/
这里我下载解压得到 mysql-connector-java-5.1.43-bin.jar
在Eclipse中新建java项目只需要Build Path --& Add External Archives把该jar包的路径添加进来就可以使用。在Android Studio中更是只需要复制粘贴到项目目录的app\libs下即可，IDE会自动加载。——看似如此。
本地Android Studio的配置
我的Android Studio版本是Community Edition，系统是win7 64位。在添加该jar文件后，build出错。
按照提示，需要在项目最外层的build.gradle文件中的allprojects { ... }区域（具体见代码下的图片，之后就不附图了）内添加下列代码
tasks.withType(JavaCompile) {
sourceCompatibility = ‘1.7‘
targetCompatibility = ‘1.7‘
这还没完，此时会提示Error: Unable to find a JDK，起初我怀疑jdk没添加进环境变量，但是cmd窗口测试无误，而且Android Studio新建项目也能编译运行。那么，还是jar包的问题。查了很久后找到了解决方案，看起来是java8的不兼容所致，所以需要全面改为Java7来编译
1、在所有module的build.gradle文件中的android { ... }区域中添加
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_7
targetCompatibility JavaVersion.VERSION_1_7
就我这个新建的项目，没有添加module，所以需要修改的文件就只有app\build.gradle
2、在主module的build.gradle文件（也就是app\build.gradle）的android { defaultConfig { ... } }区域中添加
jackOptions {
enabled true
此时编译成功了，但是注意，这才是第一步，仅仅只是成功引用了java库。Android Studio默认是不允许访问Internet的。
因此需要在app/src/main/AndroidManifest.xml中的&manifest&...&/manifest&区域内添加一行
&uses-permission android:name="android.permission.INTERNET"/&
远程mysql的配置
然后我的mysql是安装在Linux虚拟机（Ubuntu 16.04）上的，默认mysql是禁止远程连接的，所以在Linux上也要进行配置
首先是要让mysql支持中文字符，登陆mysql用户后，输入命令STATUS;可以看到几个字符集是这样的
Server characterset: latin1
characterset: latin1
Client characterset: utf8
characterset: utf8
因此需要用超级用户权限修改/etc/mysql/my.cnf，添加下列代码（这里顺便绑定了端口为3306，虽然一般默认端口也是3306）
default-character-set=utf8
default-storage-engine=INNODB
character-set-server=utf8
collation-server=utf8_general_ciport=3306
然后重启mysql，命令如下
$ /etc/init.d/mysql stop
$ /etc/init.d/mysql start
之后再登陆mysql后使用STATUS命令就可以看到字符集全部变成了utf8。
然后mysql默认绑定的IP是127.0.0.1，端口3306，在shell下可以通过shell命令netstat -apn | grep 3306查看端口占用情况，若端口3306对应的第三项（Local Address）是127.0.0.1:3306，那么mysql绑定的就是本地地址，不能远程连接。
还是用超级用户权限修改/etc/mysql/my.cnf，添加下列代码并重启mysql
bind-address=<span style="color: #.0.<span style="color: #.0
重启后再用netstat -apn | grep 3306查看第三项就会变成0.0.0.0:3306，那么mysql就支持了远程连接。
还没完，虽然mysql赋予了远程连接的权限，但是mysql用户并没有。我这里的mysql用户名是team，密码是java123，用root登陆mysql后输入下列命令
mysql& grant all on *.* to ‘%‘ identified by ‘java123‘ with grant option;
mysql& flush privileges;
‘%‘代表用户team支持远程连接，‘localhost‘则代表用户team支持本地连接
好了，终于可以写代码了，于是迫不可待地在MainAcitivity.java的onCreate()方法内部添加下列代码（先尝试连接）
// 1.加载JDBC驱动
Class.forName("com.mysql.jdbc.Driver");
Log.v(TAG, "加载JDBC驱动成功");
} catch (ClassNotFoundException e) {
Log.e(TAG, "加载JDBC驱动失败");
// 2.设置好IP/端口/数据库名/用户名/密码等必要的连接信息
String ip = "192.168.183.134";
int port = 3306;
String dbName = "XYZ";
String url = "jdbc:mysql://" + ip + ":" + port
+ "/" + dbN // 构建连接mysql的字符串
String user = "team";
String password = "java123";
// 3.连接JDBC
Connection conn = DriverManager.getConnection(url, user, password);
conn.close();
} catch (SQLException e) {
Log.e(TAG, "远程连接失败!");
这里使用了andorid.util.Log而不是System.out.println来打印消息，因为可以设置过滤符，通过TAG、日志级别等信息来筛选出特定的日志
这里我就是通过TAG来筛选，也可以通过Message和Package来筛选，并且支持正则表达式，程序运行时会有大量日志混杂在一起，所以使用Log而不是System.out来打印消息更好。
于是，通过日志过滤符筛选，可以发现连接失败了。
这个问题折磨了我一天多，参考了很多网上的代码，和我的基本无异，而且也copy过来测试过都不行，最后在stackoverflow上找到了解答
https://stackoverflow.com/questions//connecting-to-mysql-from-android-with-jdbchttps://stackoverflow.com/questions//connecting-to-mysql-from-android-with-jdbc
mysql的连接必须在异步任务类中，也就是说必须新建线程来连接mysql，而不能在主线程中执行代码。
final Thread thread = new Thread(new Runnable() {
public void run() {
// 反复尝试连接，直到连接成功后退出循环
while (!Thread.interrupted()) {
Thread.sleep(100);
// 每隔0.1秒尝试连接
} catch (InterruptedException e) {
Log.e(TAG, e.toString());
// 2.设置好IP/端口/数据库名/用户名/密码等必要的连接信息
String ip = "192.168.183.134";
int port = 3306;
String dbName = "XYZ";
String url = "jdbc:mysql://" + ip + ":" + port
+ "/" + dbN // 构建连接mysql的字符串
String user = "team";
String password = "java123";
// 3.连接JDBC
Connection conn = DriverManager.getConnection(url, user, password);
Log.i(TAG, "远程连接成功!");
conn.close();
} catch (SQLException e) {
Log.e(TAG, "远程连接失败!");
thread.start();
成功了，总算可以继续下一步，向远程连接的mysql发送命令了，将上述代码稍作修改
// 3.连接JDBC
Connection conn = null;
conn = DriverManager.getConnection(url, user, password);
Log.i(TAG, "远程连接成功!");
} catch (SQLException e) {
Log.e(TAG, "远程连接失败!");
if (conn != null) {
String sql = "SELECT * FROM pokemon";
// 创建用来执行sql语句的对象
java.sql.Statement statement = conn.createStatement();
// 执行sql查询语句并获取查询信息
ResultSet rSet = statement.executeQuery(sql);
// 迭代打印出查询信息
Log.i(TAG, "宝可梦列表");
Log.i(TAG, "ID\tName\tAttr1\tAttr2");
while (rSet.next()) {
Log.i(TAG, rSet.getString("id") + "\t" + rSet.getString("name")
+ "\t" + rSet.getString("attr1") + "\t" + rSet.getString("attr2"));
} catch (SQLException e) {
Log.e(TAG, "createStatement error");
conn.close();
} catch (SQLException e) {
Log.e(TAG, "关闭连接失败");
懒得仔细研究java格式化字符串，直接把结果打印出来了，这里只用到了执行查询语句的executeQuery，返回结果到一组迭代对象。
而execute则可以执行任何sql语句，更多API可以参考JDBC官方教程 http://docs.oracle.com/javase/tutorial/jdbc/basics/index.html标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&原文地址：http://www.cnblogs.com/Harley-Quinn/p/7389681.html
&&国之画&&&& &&&&chrome插件
版权所有 京ICP备号-2
迷上了代码！开发Android的同学都知道sdk已经为我们提供了一个SQLiteOpenHelper类来创建和管理SQLite数据库，通过写一个子类去继承它，就可以方便的创建、管理数据库。但是当我们需要去做增删改查的操作的时候，就得通过getWritableDatabase获取一个SQLiteDataBase然后老老实实去写操作值的put以及查询返回的Cursor处理，其实我们可以搞一个对象来帮我们干这些事情，打造属于你自己的数据库操作类。
2、操作类的初显形
假设现在我们什么都没有，我们要去搞一个对象来给我们干这件事情，它需要有什么才可以干呢？
先想想要做的事情：管理数据库的操作
那要做数据库的操作需要什么就很简单了吧？
1、要操作数据库，所以需要一个SQLiteDataBase对象，可以通过SQLiteOpenHelper的子类来获取。
2、此外数据库要创建，还需要数据库信息吧？那就直接变量引入。
3、有了数据库信息，创建了数据库，你要操作，怎么也得告诉我操作哪个表。所以还得包含创建表和更新表的信息，由于表一般会有多张，所以这里用一个数组变量。
有了信息还得交互，不然我怎么知道你要怎么创建表，所以我们在构造方法中直接获取这些信息。
接下看上面文字的代码表示
public abstract class DataBaseHelper {
* 用来创建和获取数据库的SQLiteOpenHelper
protected DBHelper mDbH
* 数据库对象
protected SQLiteDatabase mDb;
* 数据库信息
private int mDbV//版本
private String mDbN//数据库名
* 创建表语句
private String[] mDbCreateS
* 更新表语句
private String[] mDbUpdateS
protected abstract int getMDbVersion(Context context);
protected abstract String getDbName(Context context);
protected abstract String[] getDbCreateSql(Context context);
protected abstract String[] getDbUpdateSql(Context context);
public DataBaseHelper(Context context) {
this.mDbVersion = this.getMDbVersion(context);
this.mDbName = this.getDbName(context);
this.mDbCreateSql = this.getDbCreateSql(context);
this.mDbUpdateSql = this.getDbUpdateSql(context);
this.mDbHelper = new DBHelper(context,this.mDbName,null,this.mDbVersion);
protected void open(){
new Thread(new Runnable() {
public void run() {
mDb = mDbHelper.getWritableDatabase();
}).start();
protected SQLiteDatabase getDB(){
return this.mDb;
public void close(){
this.mDb.close();
this.mDbHelper.close();
private class DBHelper extends SQLiteOpenHelper{
public DBHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version) {
super(context, name, factory, version);
public void onCreate(SQLiteDatabase db) {
String[] arr = DataBaseHelper.this.mDbCreateS
//执行创建表语句
for (int i=0;i&arr.i++){
String sql = arr[i];
db.execSQL(sql);
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
String[] arr = DataBaseHelper.this.mDbUpdateS
//执行更新语句
for (int i=0;i&arr.i++){
String sql = arr[i];
db.execSQL(sql);
代码比较简单，包含了进行数据库操作要用到的各种信息，并且在初始化的进行了赋值。同时还提供了SQLiteDatabase的open、close。同时在这里用到了抽象方法是因为考虑创建多个数据库的情况，让子类来提供具体的数据库信息，我只管做创建和操作就行了。
这里我们的数据库操作类已经初显雏形了，但是现在除了创建表还没什么用。操作类不提供简便的操作还叫什么操作类，下面就来说说操作。
我们要做操作类，无非是要简化操作，就像当老板一样。我告诉你一些用到的东西，你去给我完成这个事情。哈哈。
假如我现在就是要操作数据库的老板，那我其实只想告诉你必要的事情，其它的我都不想做。
那么必要的信息只有表名，要操作的字段和值，如果是删除、更新、和查询的话多加个筛选条件。接下来看代码
* 统一对ContentValues处理
* @param contentValues
* @param key
* @param value
private void ContentValuesPut(ContentValues contentValues,String key,Object value){
if (value==null){
contentValues.put(key,&&);
String className = value.getClass().getName();
if (className.equals(&java.lang.String&)){
contentValues.put(key,value.toString());
} else if (className.equals(&java.lang.Integer&)){
contentValues.put(key,Integer.valueOf(value.toString()));
} else if (className.equals(&java.lang.Float&)){
contentValues.put(key,Float.valueOf(value.toString()));
} else if (className.equals(&java.lang.Double&)){
contentValues.put(key,Double.valueOf(value.toString()));
} else if (className.equals(&java.lang.Boolean&)){
contentValues.put(key,Boolean.valueOf(value.toString()));
} else if (className.equals(&java.lang.Long&)){
contentValues.put(key,Long.valueOf(value.toString()));
} else if (className.equals(&java.lang.Short&)){
contentValues.put(key,Short.valueOf(value.toString()));
* 根据数组的列和值进行insert
* @param tableName
* @param columns
* @param values
public boolean insert(String tableName,String[] columns,Object[] values){
ContentValues contentValues = new ContentValues();
for (int rows = 0; rows & columns.++rows){
ContentValuesPut(contentValues,columns[rows],values[rows]);
long rowId = this.mDb.insert(tableName,null,contentValues);
return rowId!=-1;
* 根据map来进行insert
* @param tableName
* @param columnValues
public boolean insert(String tableName,Map&String,Object& columnValues){
ContentValues contentValues = new ContentValues();
Iterator iterator = columnValues.keySet().iterator();
while (iterator.hasNext()){
String key = (String) iterator.next();
this.ContentValuesPut(contentValues,key,columnValues.get(key));
long rowId = this.mDb.insert(tableName,null,contentValues);
return rowId!=-1;
* 统一对数组where条件进行拼接
* @param whereColumns
private String initWhereSqlFromArray(String[] whereColumns){
StringBuffer whereStr = new StringBuffer();
for (int i=0;i&whereColumns.++i){
whereStr.append(whereColumns[i]).append(& = ? &);
if (i&whereColumns.length-1){
whereStr.append(& and &);
return whereStr.toString();
* 统一对map的where条件和值进行处理
* @param whereParams
private Map&String,Object& initWhereSqlFromMap(Map&String,String& whereParams){
Set set = whereParams.keySet();
String[] temp = new String[whereParams.size()];
int i = 0;
Iterator iterator = set.iterator();
StringBuffer whereStr = new StringBuffer();
while (iterator.hasNext()){
String key = (String) iterator.next();
whereStr.append(key).append(& = ? &);
temp[i] = whereParams.get(key);
if (i&set.size()-1){
whereStr.append(& and &);
HashMap result = new HashMap();
result.put(&whereSql&,whereStr);
result.put(&whereSqlParam&,temp);
* 根据数组条件来update
* @param tableName
* @param columns
* @param values
* @param whereColumns
* @param whereArgs
public boolean update(String tableName,String[] columns,Object[] values,String[] whereColumns,String[] whereArgs){
ContentValues contentValues = new ContentValues();
for (int i=0;i&columns.++i){
this.ContentValuesPut(contentValues,columns[i],values[i]);
String whereClause = this.initWhereSqlFromArray(whereColumns);
int rowNumber = this.mDb.update(tableName,contentValues,whereClause,whereArgs);
return rowNumber & 0 ;
* 根据map值来进行update
* @param tableName
* @param columnValues
* @param whereParam
public boolean update(String tableName,Map&String,Object& columnValues,Map&String,String& whereParam){
ContentValues contentValues = new ContentValues();
Iterator iterator = columnValues.keySet().iterator();
while (iterator.hasNext()){
columns = (String) iterator.next();
ContentValuesPut(contentValues,columns,columnValues.get(columns));
Map map = this.initWhereSqlFromMap(whereParam);
int rowNumber = this.mDb.update(tableName,contentValues,(String)map.get(&whereSql&),(String[]) map.get(&whereSqlParam&));
return rowNumber & 0;
* 根据数组条件进行delete
* @param tableName
* @param whereColumns
* @param whereParam
public boolean delete(String tableName,String[] whereColumns,String[] whereParam){
String whereStr = this.initWhereSqlFromArray(whereColumns);
int rowNumber = this.mDb.delete(tableName,whereStr,whereParam);
return rowNumber & 0;
* 根据map来进行delete
* @param tableName
* @param whereParams
public boolean delete(String tableName,Map&String,String& whereParams){
Map map = this.initWhereSqlFromMap(whereParams);
int rowNumber = this.mDb.delete(tableName,map.get(&whereSql&).toString(),(String[]) map.get(&whereSqlParam&));
return rowNumber & 0;
* 查询返回List
* @param sql
* @param params
public List&Map& queryListMap(String sql,String[] params){
ArrayList list = new ArrayList();
Cursor cursor = this.mDb.rawQuery(sql,params);
int columnCount = cursor.getColumnCount();
while (cursor.moveToNext()){
HashMap item = new HashMap();
for (int i=0;i&columnC++i){
int type = cursor.getType(i);
switch (type){
item.put(cursor.getColumnName(i),null);
item.put(cursor.getColumnName(i), cursor.getInt(i));
item.put(cursor.getColumnName(i),cursor.getFloat(i));
item.put(cursor.getColumnName(i),cursor.getString(i));
list.add(item);
cursor.close();
* 查询单条数据返回map
* @param sql
* @param params
public Map queryItemMap(String sql,String[] params){
Cursor cursor = this.mDb.rawQuery(sql,params);
HashMap map = new HashMap();
if (cursor.moveToNext()){
for (int i = 0;i & cursor.getColumnCount();++i){
int type = cursor.getType(i);
switch (type){
map.put(cursor.getColumnName(i),null);
map.put(cursor.getColumnName(i),cursor.getInt(i));
map.put(cursor.getColumnName(i),cursor.getFloat(i));
map.put(cursor.getColumnName(i),cursor.getString(i));
cursor.close();
public void execSQL(String sql){
this.mDb.execSQL(sql);
public void execSQL(String sql,Object[] params){
this.mDb.execSQL(sql,params);
上面的操作代码就完毕了，这里主要对增删改的参数是数组和Map的情况进行了处理，对查询的结果进行了处理，代码比较简单也都有注释，这里就不做特别说明了。到这里一个数据库操作类就成型了。
3、操作类的继续完善
通过上面的过程已经可以使用了，那么先来看看使用，我们只需要继承操作抽象类告诉它具体的数据库信息以及建表语句。
public class TestDBHelper extends DataBaseHelper {
private static TestDBHelper mTestDBH
private TestDBHelper(Context context){
super(context);
public static TestDBHelper getInstance(Context context){
if (mTestDBHelper==null){
synchronized (DataBaseHelper.class){
if (mTestDBHelper==null){
mTestDBHelper = new TestDBHelper(context);
if (mTestDBHelper.getDB()==null||!mTestDBHelper.getDB().isOpen()){
mTestDBHelper.open();
return mTestDBH
protected int getMDbVersion(Context context) {
protected String getDbName(Context context) {
return &test.db&;
protected String[] getDbCreateSql(Context context) {
String[] a = new String[1];
a[0] = &CREATE TABLE user (id INTEGER PRIMARY KEY AUTOINCREMENT,name TEXT,gender TEXT,age INTEGER)&;
protected String[] getDbUpdateSql(Context context) {
return new String[0];
重写父类的抽象方法告诉它数据库信息以及建表语句，然后提供一个单例供外部获取，如果没有open就open数据库，接下来看看使用
直接获取，然后传入你想操作的表信息，So Easy!
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
private Button selectB
private Button insertB
private Button updateB
private Button deleteB
private TextView contentTv;
private TestDBHelper testDBH
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
testDBHelper = TestDBHelper.getInstance(getApplicationContext());
selectBtn = (Button) findViewById(R.id.select_btn);
insertBtn = (Button) findViewById(R.id.insert_btn);
updateBtn = (Button) findViewById(R.id.update_btn);
deleteBtn = (Button) findViewById(R.id.delete_bt);
contentTv = (TextView) findViewById(R.id.content_tv);
selectBtn.setOnClickListener(this);
insertBtn.setOnClickListener(this);
updateBtn.setOnClickListener(this);
deleteBtn.setOnClickListener(this);
public void onClick(View v) {
switch (v.getId()){
case R.id.select_btn:
List&Map& list = testDBHelper.queryListMap(&select * from user&,null);
contentTv.setText(String.valueOf(list));
case R.id.insert_btn:
testDBHelper.insert(&user&,new String[]{&name&,&gender&,&age&},new Object[]{&qiangyu&,&male&,23});
case R.id.update_btn:
testDBHelper.update(&user&,new String[]{&name&,&gender&,&age&},new Object[]{&yangqiangyu&,&male&,24},
new String[]{&name&},new String[]{&qiangyu&});
case R.id.delete_bt:
testDBHelper.delete(&user&,
new String[]{&name&},new String[]{&qiangyu&});
很简单了，附一张演示图
gif制作了做了压缩,图的效果不好请见谅
是不是简单多了
**yissan的博客,未经允许严禁转载
5、最后的完善
在第3步里，我们的数据库信息，和建表语句都是写在具体的代码里的，这样我们每次修改都要动代码。Android推荐我们这些具体的信息都写在配置文件xml里面，那么我们就来做一下修改。
建立一个db.xml
&?xml version=&1.0& encoding=&utf-8&?&
&resources&
&array name=&DATABASE_INFO&&
&item&test.db&/item&
&item&1&/item&
&array name=&CREATE_TABLE_SQL&&
&item&CREATE TABLE user (id INTEGER PRIMARY KEY AUTOINCREMENT,name TEXT,gender TEXT,age INTEGER)&/item&
&array name=&UPDATE_TABLE_SQL&&
&item&&/item&
&/resources&
现在的获取数据信息的代码是这样
protected int getMDbVersion(Context context) {
return Integer.valueOf(context.getResources().getStringArray(R.array.DATABASE_INFO)[1]);
protected String getDbName(Context context) {
return context.getResources().getStringArray(R.array.DATABASE_INFO)[0];
protected String[] getDbCreateSql(Context context) {
return context.getResources().getStringArray(R.array.CREATE_TABLE_SQL);
protected String[] getDbUpdateSql(Context context) {
return context.getResources().getStringArray(R.array.UPDATE_TABLE_SQL);
从配置文件当中获取数据库信息，这样以后每次修改只需要修改xml文件就可以了。
到此，一个数据库操作类就完成啦，当然你可以根据自己的需要在其实添加更多的便捷操作方法。
这里提供的操作类，在使用的时候我们还在需要在Activity中写一些查询的sql代码，我们可以再搞一个统一做各种具体操作表的对象。
觉得不错别忘记点赞哟！
最后送给大家一个鸡汤，共勉
他每做一件小事的时候 他都像救命稻草一样抓着 有一天我一看 嚯 好家伙 他抱着的是已经是让我仰望的参天大树
阅读(...) 评论()android studio怎么进行数据库操作啊
[问题点数：100分，结帖人qq_]
android studio怎么进行数据库操作啊
[问题点数：100分，结帖人qq_]
只显示楼主
取消只显示楼主
匿名用户不能发表回复！|&>&Android Studio远程数据库操作实现源码
Android Studio远程数据库操作实现源码
上传大小：19.42MB
Android Studio远程数据库操作实现源码，简单界面，附文档资料。
综合评分：0
下载个数：
{%username%}回复{%com_username%}{%time%}\
/*点击出现回复框*/
$(".respond_btn").on("click", function (e) {
$(this).parents(".rightLi").children(".respond_box").show();
e.stopPropagation();
$(".cancel_res").on("click", function (e) {
$(this).parents(".res_b").siblings(".res_area").val("");
$(this).parents(".respond_box").hide();
e.stopPropagation();
/*删除评论*/
$(".del_comment_c").on("click", function (e) {
var id = $(e.target).attr("id");
$.getJSON('/index.php/comment/do_invalid/' + id,
function (data) {
if (data.succ == 1) {
$(e.target).parents(".conLi").remove();
alert(data.msg);
$(".res_btn").click(function (e) {
var parentWrap = $(this).parents(".respond_box"),
q = parentWrap.find(".form1").serializeArray(),
resStr = $.trim(parentWrap.find(".res_area_r").val());
console.log(q);
//var res_area_r = $.trim($(".res_area_r").val());
if (resStr == '') {
$(".res_text").css({color: "red"});
$.post("/index.php/comment/do_comment_reply/", q,
function (data) {
if (data.succ == 1) {
var $target,
evt = e || window.
$target = $(evt.target || evt.srcElement);
var $dd = $target.parents('dd');
var $wrapReply = $dd.find('.respond_box');
console.log($wrapReply);
//var mess = $(".res_area_r").val();
var mess = resS
var str = str.replace(/{%header%}/g, data.header)
.replace(/{%href%}/g, 'http://' + window.location.host + '/user/' + data.username)
.replace(/{%username%}/g, data.username)
.replace(/{%com_username%}/g, data.com_username)
.replace(/{%time%}/g, data.time)
.replace(/{%id%}/g, data.id)
.replace(/{%mess%}/g, mess);
$dd.after(str);
$(".respond_box").hide();
$(".res_area_r").val("");
$(".res_area").val("");
$wrapReply.hide();
alert(data.msg);
}, "json");
/*删除回复*/
$(".rightLi").on("click", '.del_comment_r', function (e) {
var id = $(e.target).attr("id");
$.getJSON('/index.php/comment/do_comment_del/' + id,
function (data) {
if (data.succ == 1) {
$(e.target).parent().parent().parent().parent().parent().remove();
$(e.target).parents('.res_list').remove()
alert(data.msg);
//填充回复
function KeyP(v) {
var parentWrap = $(v).parents(".respond_box");
parentWrap.find(".res_area_r").val($.trim(parentWrap.find(".res_area").val()));
评论共有7条
压缩文件坏了，打不开
调试通过，是真的。
认真学习，努力找资源。
VIP会员动态
CSDN下载频道资源及相关规则调整公告V11.10
下载频道用户反馈专区
下载频道积分规则调整V1710.18
spring mvc+mybatis+mysql+maven+bootstrap 整合实现增删查改简单实例.zip
资源所需积分/C币
当前拥有积分
当前拥有C币
输入下载码
为了良好体验，不建议使用迅雷下载
Android Studio远程数据库操作实现源码
会员到期时间：
剩余下载个数：
剩余积分：0
为了良好体验，不建议使用迅雷下载
积分不足！
资源所需积分/C币
当前拥有积分
您可以选择
程序员的必选
绿色安全资源
资源所需积分/C币
当前拥有积分
当前拥有C币
为了良好体验，不建议使用迅雷下载
资源所需积分/C币
当前拥有积分
当前拥有C币
为了良好体验，不建议使用迅雷下载
资源所需积分/C币
当前拥有积分
当前拥有C币
您的积分不足，将扣除 10 C币
为了良好体验，不建议使用迅雷下载
无法举报自己的资源
你当前的下载分为234。
你还不是VIP会员
开通VIP会员权限，免积分下载
你下载资源过于频繁，请输入验证码
您因违反CSDN下载频道规则而被锁定帐户，如有疑问，请联络:!
若举报审核通过，可返还被扣除的积分
被举报人：
举报的资源分：
请选择类型
资源无法下载 （ 404页面、下载失败、资源本身问题）
资源无法使用 （文件损坏、内容缺失、题文不符）
侵犯版权资源 （侵犯公司或个人版权）
虚假资源 （恶意欺诈、刷分资源）
含色情、危害国家安全内容
含广告、木马病毒资源
*详细原因：
Android Studio远程数据库操作实现源码}