精华内容
下载资源
问答
  • PHP面向对象操作数据库

    千次阅读 2016-12-16 11:13:36
    PHP面向过程中,我们可以通过封装函数来实现对数据库的操作,...一共分为连接数据库的config文件、具体实现对数据库操作的类文件、测试代码。所有的代码均是通过了测试,具体的测试结果由于篇幅问题没有附图。

      在PHP的面向过程中,我们可以通过封装函数来实现对数据库的操作,那么在面向过程中,我们同样可以通过类来实现对数据库的操作,整个过程和面向过程的思路大体差不多,但是代码量更多了一些,实现起来稍微困难。一共实现了十个功能。先定义成员属性,然后定义成员方法。一共分为连接数据库的config文件、具体实现对数据库操作的类文件、测试代码。所有的代码均是通过了测试,具体的测试结果由于篇幅问题没有附图。

    具体实现功能:

    1、连接数据库;

    2、插入数据;

    3、更新数据;

    4、删除数据;

    5、修改数据;

    6、求最大值;

    7、求最小值;

    8、求平均数;

    9、求和;

    10、指定查询;

    具体代码分为三个部分:

    一、config文件:主要用于连接数据库

    <?php
    return array(
    	'DB_HOST' => '127.0.0.1',   //主机
    	'DB_USER' => 'root',		//用户名	
    	'DB_PWD' => '123456',		//密码
    	'DB_NAME' => 'blog',		//数据库名
    	'DB_CHARSET' => 'utf8',		//字符集
    	'DB_PREFIX' => 'bbs_',		//前缀
    
    );

    二、数据库操作类:

    <?php
    /**
     * 数据库操作类
     */
    class UserModel
    {
    	/*
    	成员属性
    	 */
    	//链接
    	protected $link;
    	//主机
    	protected $host;
    	//数据库名字
    	protected $dbName;
    	//字符集
    	protected $charset;
    	//表名
    	protected $table;
    	//用户名
    	protected $user;
    	//密码
    	protected $pwd;
    	//表前缀
    	protected $prefix;
    	//字段
    	protected $fields;
    	//保存的查询、更新、添加的参数
    	protected $options;
    
    	/*
    	成员方法
    	 */
    
    	//初始化数据库
    	public function __construct(Array $config)
    	{
    		//把一批成员属性都初始化
    		$this->host = $config['DB_HOST'];
    		$this->user = $config['DB_USER'];
    		$this->pwd = $config['DB_PWD'];
    		$this->dbName = $config['DB_NAME'];
    		$this->charset = $config['DB_CHARSET'];
    		$this->prefix = $config['DB_PREFIX'];
    		//连接
    		$this->link = $this->connect();
    		//判断连接成功与否  失败处理
    		if (!$this->link) {
    			exit('数据库连接或者选择数据库失败。');
    		}
    
    		//表名  需要处理
    		$this->table = $this->getTable();
    
    		//字段 	需要处理
    		$this->fields = $this->getFields();
    
    
    
    	}
    
    	//连接数据库成员方法
    	protected function connect()
    	{
    		$conn = mysqli_connect($this->host,$this->user,$this->pwd);
    
    		//连接数据库失败处理
    		if (!$conn) {
    
    			return flase;
    		}
    
    		//选择数据失败处理
    		if (!mysqli_select_db($conn,$this->dbName)) {
    
    			return false ;
    		}
    		//设置字符集
    		mysqli_set_charset($conn,$this->charset);
    
    		//返回处理结果
    		return $conn;
    
    	}
    	//初始化表 【暂时出现报错,后面用命名空间解决】
    	protected function getTable()
    	{
    		//判断用户时候设置过?
    		if (isset($this->table)) {
    
    			//设置过就以用户的为准,先把用户前缀弃掉,然后拼接前缀,保证统一性
    			return $this->prefix . ltrim($this->table,$this->prefix);
    		} else {
    
    			//没有设置过就用 类名拼接前缀,组成一个全新的的表名
    			//get_class() 获取类名 等同于 __CLASS__
    			//获取类名后进行字串提取[substr( string,start,length )],并且全部转换为小写[strtolower()]
    			return $this->prefix . strtolower(substr(get_class($this),0,-5));
    		}
    	}
    	//初始化字段 需要把字段缓存到一个文件里面去
    	protected function getFields()
    	{
    		//如果有字段的文件说明以前缓存过这个文件,直接包含即可,但是需要知道文件路径的规则
    		//定义文件路径
    		$filePath = './caceh/' . $this->table . '.php';
    
    		//判断时候有缓存文件
    		if (file_exists($filePath)) {
    
    			//存在缓存文件直接包含即可
    			return include $filePath;
    		} else {
    
    			//没有的话就需要生成一个缓存文件
    			//首先需要查询字段
    			$fields = $this->queryFields();
    
    			//var_export() 输出或返回一个变量的字符串  true表示不打印  将其保存下来
    			$str = "<?php \n return ". var_export($fields,true) . ';?>';
    			//写入到缓存文件file_put_contents(文件保存路径,需要写进去的内容)
    			file_put_contents($filePath, $str);
    
    		}
    		return $fields;
    
    
    	}
    
    	//查询字段处理
    	protected function queryFields()
    	{
    		//打印字段的sql语句
    		$sql = 'desc ' . $this->table;
    		//var_dump($sql);
    		//执行sql语句  需要定义成员方法query
    		$data = $this->query($sql);
    
    		$fields = [];
    		//想要获取字段,需要对返回的数据进行遍历
    		foreach ($data as $key => $value) {
    			$fields[] = $value['Field'];
    			if ($value['Key'] == 'PRI') {
    				$fields['_pk'] = $value['Field'];
    			}
    		}
    		return $fields;
    
    
    	}
    
    	//系统级查询(定义为 public ),在外部调用的时候,想自定义SQL语句可以只是调用该成员方法
    	//查询相应的结果,这个仅供读取使用查询相应的结果
    	public function query($sql)
    	{
    		//执行一条SQL语句
    		$result = mysqli_query($this->link,$sql);
    
    		if ($result) {
    			$data = [];
    			//获取每行数据
    			while ($row = mysqli_fetch_assoc($result)) {
    				$data[] = $row;
    			}
    			return $data;
    
    		} else {
    			return false;
    		}
    
    
    	}
    
    	//查询成员方法
    	//准备好无需换的SQL语句
    	//用户调用询的时候,将call里面保存进去的参数,一一替换sql语句
    	//发送SQL语句
    	//返回查询的结果
    	public function select()
    	{
    		//拼接sql语句
    		$sql = "select %FIELDS% from %TABLE% %WHERE% %GROUP% %HAVING% %ORDER% %LIMIT%";
    
    		//将sql语句中的相应部分替换
    		$newsql = str_replace(
    					array(
    						'%FIELDS%',
    						'%TABLE%',
    						'%WHERE%',
    						'%GROUP%',
    						'%HAVING%',
    						'%ORDER%',
    						'%LIMIT%',
    					),
    					array(
    						$this->parseFields(),
    						$this->parseTable(),
    						$this->parseWhere(),
    						$this->parseGroup(),
    						$this->parseHaving(),
    						$this->parseOrder(),
    						$this->parseLimit(),
    					),
    					$sql
    				);
    		echo $newsql;
    		$this->sql = $newsql;
    		return $this->query($newsql);
    	}
    	//字段处理
    	protected function parseFields()
    	{
    		//因为我们对比字段的时不需要对比主键是谁,所以需要unset()
    		//将当前的字段赋值给一个变量
    		$fields = $this->fields;
    
    		unset($fields['_pk']);
    
    		//判断字段是什么形式(字符串、数组)
    		if (is_array($this->options['fields'][0])) {
    
    			//遍历取出键值
    			foreach ($this->options['fields'][0] as $key => $value) {
    				//判断传入的字段时候合法(属于表结构中的字段)
    				if (!in_array($value, $fields)) {
    					//如果不属于合法的字段就unset()
    					unset($this->options['fields'][0][$key]);
    				}
    			}
    			return join(',',$this->options['fields'][0]);
    
    		} else if (is_string($this->options['fields'][0])){
    			//如果是字符串就先变为数组进行处理
    			$this->options['fields'][0] = explode(',', $this->options['fields'][0]);
    			//遍历
    			foreach ($this->options['fields'][0]  as $key => $value) {
    				//判断字段是否合法
    				if (!in_array($value,$fields)) {
    
    					unset($this->options['fields'][0][$key]);
    				}
    				return join(',',$this->options['fields'][0]);
    			}
    
    		} else {
    			return join(',',$fields);
    		}
    
    	}
    
    	//判断用户有没有手动指定过查询哪个用
    	//如果指定过,则以用户设定的options里面的表为准
    	//如果没有设定过,则以默认的为准
    	protected function parseTable()
    	{
    		if (isset($this->options['table'][0])) {
    			return $this->options['table'][0];
    		} else {
    			return $this->table;
    		}
    
    	}
    
    
    	//判断用户设置过where 如果设置过就以用户设置为准,没有设置就为空
    
    	protected function parseWhere()
    	{
    		if (isset($this->options['where'][0])) {
    			return 'WHERE ' .$this->options['where'][0];
    		} else {
    			return '';
    		}
    	}
    
    
    	//判断用户设置过group 如果设置过就以用户设置为准,没有设置就为空
    
    	protected function parseGroup()
    	{
    		if (isset($this->options['where'][0])) {
    			return 'GROUP BY ' .$this->options['group'][0];
    		} else {
    			return '';
    		}
    	}
    
    	//判断用户设置过having如果设置过就以用户设置为准,没有设置就为空
    
    	protected function parseHaving()
    	{
    		if (isset($this->options['having'][0])) {
    			return 'HAVING ' .$this->options['having'][0];
    		} else {
    			return '';
    		}
    	}
    
    	//判断用户设置过order如果设置过就以用户设置为准,没有设置就为空
    	protected function parseOrder()
    	{
    		if (isset($this->options['order'][0])) {
    			return 'ORDER BY ' .$this->options['order'][0];
    		} else {
    			return '';
    		}
    	}
    
    	//limit可以有以下几种传法
    
    
    	protected function parseLimit()
    	{
    		if (isset($this->options['limit'][0])) {
    
    			if (is_int($this->options['limit'][0])) {
    
    				//用户传进来的是一个整 数,就是查询指定的条数
    				return 'LIMIT ' . $this->options['limit'][0];
    
    			} else if (is_array($this->options['limit'][0])){
    
    				//用户传进来的是一个数组,则数组中的第一个元素为$offset,第二个元素为$num
    				return 'LIMIT ' . join(',',$this->options['limit'][0]);
    			} else {
    
    				//如果户传进来的是一个字符串,则以用户传的为准
    				return 'LIMIT ' . $this->options['limit'][0];
    			}
    		} else {
    
    			return '';
    		}
    	}
    
    	//插入的成员方法
    	public function insert($data)
    	{
    		//SQL语句
    		$sql = "insert into %TABLE%(%FIELDS%) values(%VALUES%) ";
    		//替换
    		$newsql = str_replace(
    						array(
    							'%TABLE%',
    							'%FIELDS%',
    							'%VALUES%'
    						),
    						array(
    							$this->parseTable(),
    							$this->parseInsertFieldes($data),
    							join (',',$this->parseValue($data)),
    						),
    						$sql
    					);
    		//重新赋值
    		$this->sql = $newsql;
    		echo $this->sql;
    		//调用exec并执行
    		return $this->exec($newsql,true);
    
    	}
    	//处理插入时候的字段
    	protected function parseInsertFieldes(&$data)
    	{
    		foreach ($data as $key => $value) {
    			if (!in_array($key,$this->fields)) {
    				unset($data[$key]);
    			}
    		}
    		return join(',',array_keys($data));
    	}
    
    	//处理插入时候的值
    	//分为字符串  数组 空的情况处理
    	protected function parseValue($data)
    	{
    
    		if (is_string($data)) {
    			$data = '\'' . $data . '\'';
    		} else if (is_array($data)){
    			$data = array_map(array($this, 'parseValue'),$data);
    		} else if (is_null($data)){
    			$data = 'null';
    		}
    
    		return $data;
    	}
    	//
    	public function exec($sql,$isInsertId = false)
    	{
    		$result = mysqli_query($this->link,$sql);
    
    		if ($result) {
    
    			if ($isInsertId) {
    				//insertfan返回自动增长的id
    				return mysqli_insert_id($this->link);
    			} else {
    				//update delete 返回受影响的行数
    
    				return mysqli_affected_rows($this->link);
    			}
    		} else {
    			return false;
    		}
    	}
    
    	//更新方法
    	public function update($data)
    	{
    		$sql = "update %TABLE% set %SETS% %WHERE% %ORDER% %LIMIT%";
    
    		$newsql = str_replace(
    					array(
    						'%TABLE%',
    						'%SETS%',
    						'%WHERE%',
    						'%ORDER%',
    						'%LIMIT%'
    					),
    					array(
    						$this->parseTable(),
    						$this->parseSets($data),
    						$this->parseWhere(),
    						$this->parseOrder(),
    						$this->parseLimit(),
    					),
    					$sql
    				);
    		$this->sql = $newsql;
    		//echo $newsql;
    		return $this->exec($newsql);
    
    	}
    
    	//更新内容设置
    	protected function parseSets($data)
    	{
    		$sets = [];
    		foreach ($data as $key => $value) {
    			 if (in_array($key,$this->fields)) {
    			 	$sets[] = $key . '=' . $this->parseValue($value);
    			 }
    		}
    		return join(',',$sets);
    	}
    
    
    	//删除方法
    	public function delete()
    	{
    		$sql = "delete from %TABLE% %WHERE% %ORDER% %LIMIT%";
    
    		$newsql = str_replace(
    					array(
    						'%TABLE%',
    						'%WHERE%',
    						'%ORDER%',
    						'%LIMIT%'
    					),
    					array(
    						$this->parseTable(),
    						$this->parseWhere(),
    						$this->parseOrder(),
    						$this->parseLimit(),
    					),
    					$sql
    				);
    
    		$this->sql = $newsql;
    
    		return $this->exec($newsql);
    	}
    
    	//求总数
    	public function sum($field = null )
    	{
    		if (is_null($field)) {
    			$field = $this->fields['_pk'];
    		}
    
    		$sql = "select count($field) as sum from %TABLE% %WHERE% ";
    
    		$newsql = str_replace(
    						array(
    							'%TABLE%',
    							'%WHERE%',
    						),
    						array(
    							$this->parseTable(),
    							$this->parseWhere(),
    							),
    						$sql
    				);
    		$this->sql = $newsql;
    		$data = $this->query($newsql);
    		return $data[0]['sum'];
    	}
    	//求最大数
    	public function max($field = null )
    	{
    		if (is_null($field)) {
    			$field = $this->fields['_pk'];
    		}
    
    		$sql = "select max($field) as max from %TABLE% %WHERE% ";
    
    		$newsql = str_replace(
    					array(
    						'%TABLE%',
    						'%WHERE%',
    					),
    					array(
    						$this->parseTable(),
    						$this->parseWhere(),
    					),
    					$sql
    				);
    		$this->sql = $newsql;
    		$data = $this->query($newsql);
    		return $data[0]['max'];
    	}
    	//求最小数
    	public function min($field = null )
    	{
    		if (is_null($field)) {
    			$field = $this->fields['_pk'];
    		}
    
    		$sql = "select min($field) as min from %TABLE% %WHERE% ";
    
    		$newsql = str_replace(
    					array(
    						'%TABLE%',
    						'%WHERE%',
    					),
    					array(
    						$this->parseTable(),
    						$this->parseWhere(),
    					),
    					$sql
    				);
    		$this->sql = $newsql;
    		$data = $this->query($newsql);
    		return $data[0]['min'];
    	}
    	//求平均数
    	public function avg($field = null )
    	{
    		if (is_null($field)) {
    			$field = $this->fields['_pk'];
    		}
    
    		$sql = "select avg($field) as avg from %TABLE% %WHERE% ";
    
    		$newsql = str_replace(
    					array(
    						'%TABLE%',
    						'%WHERE%',
    					),
    					array(
    						$this->parseTable(),
    						$this->parseWhere(),
    					),
    					$sql
    				);
    		$this->sql = $newsql;
    		$data = $this->query($newsql);
    		return $data[0]['avg'];
    	}
    
    
    	//自动的一个按照字段来查询的智能化查询方法
    	protected function getBy($field,$value)
    	{
    		$sql = "select %FIELDS% from %TABLE% %WHERE%";
    
    		$newsql = str_replace(
    					array(
    						'%FIELDS%',
    						'%TABLE%',
    						'%WHERE%'
    					),
    					array(
    						$this->parseFields(),
    						$this->parseTable(),
    						' WHERE '.$field . "='$value'",
    					),
    					$sql
    				);
    		$this->sql = $newsql;
    		echo $newsql;
    		return $this->query($newsql);
    	}
    
    	//__call方法,针对用户请求limit(), order(),group()等将其保存到options中, 判断其方法合法性;
    	//并且return $this 让其能够连贯操作,
    	public function __call($func,$args)
    	{
    		//合法的
    		$allow = ['where','table','fields','order','limit','group','having'];
    		//把传入的统一转化为小写
    		$func = strtolower($func);
    		if (in_array($func,$allow)) {
    			$this->options[$func] = $args;
    			return $this;
    		} else if(substr($func,0,5) == 'getby'){
    			$field = substr($func,5);
    
    			if (in_array($field,$this->fields)) {
    				return $this->getBy($field,$args[0]);
    			}
    		} else {
    			exit ('方法不合法!');
    		}
    
    	}
    
    	//析構方法 關閉頁面/對象消費時候調用
    	public function __destruct()
    	{
    		mysqli_close($this->link);
    	}
    }

    三、测试(验证)代码:

    //包含文件
    $config = include 'config.php';
    
    $blog = new UserModel($config);
    //测试查询
    
    $data = $blog->fields('uid,uesrname,password')->table('bbs_user')->limit([1,2])->order('uid desc ')->group('username')->select();
    
    var_dump($data);
    
    //插入测试
    $_POST['uesrname'] = 'chen';
    $_POST['password'] = 123456;
    $_POST['creatime'] = 123423;
    
    $_POST['senlin'] = '不存在的字段处理';
    
    echo $blog->insert($_POST);
    
    //更新测试
    
    $_POST['uesrname'] = '1kkkkk12';
    $_POST['password'] = 123456;
    $_POST['createtime'] = 234567;
    $_POST['haiyan'] = '你可长点心眼吧';
    echo $blog->where('uid>0')->limit('1')->update($_POST);
    
    //删除测试
    echo $blog->where('uid>0 and uid<2')->delete();
    
    //测试求和
    echo $blog->sum('uid');
    
    //测试求最大数
    echo $blog->max('uid');
    
    //测试求最小数
    echo $blog->min();
    
    //测试求平均數
    echo $blog->avg();
    
    //测试自动的一个按照字段来查询
    $data = $blog->getByPassword('123456');
    var_dump($data);
    展开全文
  • PHP面向对象连接MySQL数据库

    千次阅读 2018-09-28 14:35:17
    连接数据库面向对象为主,面向过程为辅。 连接数据库的步骤:(有一定的想法和思维,做事事半功倍) 1.连接数据库 2.设置编码 3.选择数据库 4.组合sql语句 5.执行sql语句 6.关闭连接 A.连接数据库、关闭数据库、...

    PHP:

    连接MySQL数据库

        记录一下最近所学的东西,可以以后自己复习,也可以将自己的所学分享给需要的人,一举两得。
    

    连接数据库以面向对象为主,面向过程为辅。

    连接数据库的步骤:(有一定的想法和思维,做事事半功倍)
    1.连接数据库
    2.设置编码
    3.选择数据库
    4.组合sql语句
    5.执行sql语句
    6.关闭连接

    A.连接数据库、关闭数据库、查询一条SQL语句
    在这里插入图片描述

    B、查询一条SQL语句、查询所有SQL语句(几乎一样,就是返回的时候注意!)
    在这里插入图片描述

    C、添加SQL语句(一点要细心)
    在这里插入图片描述

    D、修改SQL语句
    在这里插入图片描述

    E、删除
    在这里插入图片描述

    注:命名变量看个人习惯,但一定要规范。

    展开全文
  • php PDO面向对象的方式连接数据库

    千次阅读 2015-10-03 19:20:59
    实例 $serverName="localhost"; $username="root"; $password="admin"; $dbName="test"; try{ $conn=new PDO("mysql:host=$serverName;dbname=$dbName",$username,$password);... $conn->setAt

    实例

       $serverName="localhost";
       $username="root";
       $password="admin";
       $dbName="test";
    
       try{
           $conn=new PDO("mysql:host=$serverName;dbname=$dbName",$username,$password);
           $conn->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);
           $sql="CREATE TABLE `hello`(
            `id` int(6) UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
             `firstname` VARCHAR(30) NOT NULL,
             `lastname`  VARCHAR(30) NOT NULL,
             `email`     VARCHAR(50) NOT NULL,
             `arg_date`  TIMESTAMP 
           )";
    
          echo "table hello created successfully!";
       }catch(PDOException $e){
          echo $sql."<br>".$e->getMessage();
       }
    
      $conn=null;
    展开全文
  • PHP通过面向对象实现数据库备份

    千次阅读 2014-04-07 19:19:34
    <?php /** file: dbbackup.class.php 数据库备份类文件,备份文件放在/backup 目录下 package: sql */ date_default_timezone_set('PRC'); //设置时区 class D

    参照了网上一些文档,最后自己总结写出了两个类,我试了,可以实现数据库备份与上传功能
    <?php
        /**
            file: dbbackup.class.php
            数据库备份类文件,备份文件放在/backup 目录下
            package: sql
        */
        date_default_timezone_set('PRC');                              //设置时区
        
        class Dbbackup {
            private $path = "sql/backup/";                           //SQL文件保存路径,默认为/backup
            private $database;                                         //所要备份的数据库的名称
            private $size;                                             //分卷分件大小
            private $fileName;                                         //SQL文件名
            
            private $ds = "\n";                                        //换行符
            private $sqlEnd = ";";                                     //每条SQL语句的结尾符号
            
            
            /**
            *构造方法,用来实例化备份类对象
            *@param    string    $database      数据库名称,默认值为‘lighting’
            *@param    int       $size          分卷文件大小,默认值为2048
            */
            function __construct($size = 2048, $database = 'lighting') {
                $this->database = $database;                           //设置所要备份的数据库,默认为 lighting
                $this->size = $size;                                   //分卷文件大小,默认为2MB
                $this->fileName = date('YmdHis')."_all";
                
                ob_end_flush();                                        //清除所有缓存
            }
            
            /**
            *公用方法,进行数据库备份
            *@return bool   是否备份成功
            */
            public function backup() {
                $sqlFile = '';                                         //准备写入数据库的信息
                
                $this->showMess("正在备份");
                /*备份指定数据库中所有的数据表*/
                if ($tables = mysql_query( "SHOW TABLE STATUS FROM ".$this->database)) {
                    $this->showMess("读取数据库结构成功!");
                }
                else {
                    $this->showMess("读取数据库结构失败!", true);
                    exit(0);
                }
                
                $sqlFile .= $this->retrieve();                             //写入头部dump信息
                $tables = mysql_query("SHOW TABLES");                      //查询数据库中所有的表
                $paper = 1;                                                //分卷标示
                
                while($table = mysql_fetch_array($tables)) {
                    $tableName = $table[0];                                //获取表名
                    
                    $sqlFile .= $this->insertTableStructure($tableName);   //获取表结构
                    
                    $data = mysql_query("SELECT * FROM ".$tableName);      //获取表中数据
                    $num_fields = mysql_num_fields($data);
                    
                    /*遍历表中所有数据记录*/
                    while($record = mysql_fetch_array($data)) {
                        $sqlFile .= $this->insertRecord($tableName, $num_fields, $record);  //单条数据记录
                        /*如果大于分卷大小,则写入文件*/
                        if($sqlFile >= $this->size*1000) {
                            $file = $this->fileName."_v".$paper.".sql";         //SQL文件名
                            
                            /*将SQL数据写入文件*/
                            if($this->writeFile($sqlFile,$file)) {
                                $this->showMess("-卷-<b>".$paper."</b>-数据备份完成,备份文件 [ <span>".$this->path.$file."</span> ]");
                            }
                            else {
                                $this->showMess("卷-<b>".$paper."</b>-备份失败",true);
                                
                                return false;
                            }
                            
                            /*下一个分卷*/
                            $paper ++;
                            /*重置$sqlFile变量为空,重新计算该变量大小*/
                            $sqlFile = "";
                        }
                        else {
                            /*如果SQL文件没有超过分卷大小,直接写入文件*/
                            $file = $this->fileName.".sql";         //SQL文件名
                            
                            if($this->writeFile($sqlFile,$file)) {
                                $this->showMess("-卷-<b>".$paper."</b>-数据备份完成,备份文件 [ <span>".$this->path.$file."</span> ]");
                            }
                            else {
                                $this->showMess("卷-<b>".$paper."</b>-备份失败",true);
                                
                                return false;
                            }
                        }
                        
                        $this->showMess("恭喜您! <span>备份成功</span>");
                    }
                }
            }
             
            /**
            *类内部调用的私有方法,进行提示信息输出
            *@param string  $mess   提示信息
            *@param bool    $err    错误信息标示符,默认为false,true为输出错误信息
            */
            private function showMess($mess, $err = false) {
                if($err)
                    $err = "<span>ERROR:</span>";
                else 
                    $err = '';
                
                echo "<p>".$err.$mess."</p>";
            }
            
            /**
            *类内部调用的私有方法,添加数据库备份文件头部基础信息
            *@return     string     $value   头部基础信息
            */
            private function retrieve() {
                $value = '';
                $value .= '--'.$this->ds;
                $value .= '-- MySQL database dump'.$this->ds;
                $value .= '--' . $this->ds;
                $value .= '-- 主机: '.$_SERVER['SERVER_NAME'].$this->ds;
                $value .= '-- 生成日期: '.date('Y').'年 '.date('m').'月'.date('d').'日'.date('H:i').$this->ds;
                $value .= '-- MySQL版本: '.mysql_get_server_info().$this->ds;
                $value .= '-- PHP 版本: '.phpversion().$this->ds;
                $value .= $this->ds;
                $value .= '--'.$this->ds;
                $value .= '-- 数据库:`'.$this->database.'`'.$this->ds;
                $value .= '--'.$this->ds.$this->ds;
                $value .= '-- -------------------------------------------------------';
                $value .= $this->ds.$this->ds;
                
                return $value;
            }
            
            /**
            *类内部调用的私有方法,将表结构信息插入
            *@param  string  $tableName        提示信息
            *@return string  $sqlFileTable    返回表结构
            */
            private function insertTableStructure($tableName) {
                $sqlFileTable = '';
                $sqlFileTable .= "--".$this->ds;
                $sqlFileTable .= "-- 表的结构".$tableName.$this->ds;
                $sqlFileTable .= "--".$this->ds.$this->ds;
                
                /*如果数据库中存在此表,进行删除(用户数据库文件导入时)*/
                $sqlFileTable .= "DROP TABLE IF EXISTS `".$tableName.'`'.$this->sqlEnd.$this->ds;
                
                /*获取详细表信息*/
                $res = mysql_query('SHOW CREATE TABLE `'.$tableName.'`');
                $row = mysql_fetch_array($res);
                $sqlFileTable .= $row[1];
                $sqlFileTable .= $this->sqlEnd.$this->ds;
                
                /*加上表数据提示*/
                $sqlFileTable .= $this->ds;
                $sqlFileTable .= "--".$this->ds;
                $sqlFileTable .= "-- 转存表中的数据 ".$tableName.$this->ds;
                $sqlFileTable .= "--".$this->ds;
                $sqlFileTable .= $this->ds;
                
                return $sqlFileTable;
            }
            
            /**
            *类内部调用的私有方法,将表中的数据插入
            *@param string     $tableName       表名
            *@param int        $num_fields      表中数据条数
            *@param array      $record          表中的数据
            *@return    string      $insert     表中该条数据中所有字段中的数据组成的字符串
            */
            private function insertRecord($tableName, $num_fields, $record) {
                $insert = '';                                              // sql字段逗号分割
                $comma = "";
                $insert .= "INSERT INTO `".$tableName."` VALUES(";
                
                /*循环每个子段下面的内容*/
                for($i = 0; $i < $num_fields; $i++) {
                    $insert .= ($comma."'".mysql_real_escape_string($record[$i])."'");
                    $comma = ",";
                }
                $insert .= ");".$this->ds;
                
                return $insert;
            }
            
            /**
            *@param string $sqlFile     所要写入的SQL数据
            *@param string $filename    SQL备份文件名
            *@return    bool    $re     返回是否成功写入SQL文件
            */
            private function writeFile($sqlFile, $filename) {
                $re = true;
                if (!$fp =fopen($this->path.$filename, "x")) {
                    $re = false;
                    $this->showMess("打开sql文件失败!", true);
                }
                if (!fwrite($fp,$sqlFile)) {
                    $re = false;
                    $this->showMess("写入sql文件失败,请文件是否可写", true);
                }
                if (!fclose($fp)) {
                    $re = false;
                    $this->showMess("关闭sql文件失败!", true);
                }
                
                return $re;
            }
            
            /*析构函数*/
            function __destruct() {
                echo "再见<br />";
            }
        }
        
    ?>
    <?php
        /**
            file: dbupdata.class.php
            数据库更新类文件,将放在/backup 文件下的对应SQL文件更新到数据库
            package: sql
        */
        class Dbupdata {
            private $fileName;                                          //需要上传的文件的名称
            private $path = "sql/backup/";                            //SQL文件所在路径,默认为/backup
            private $database;                                          //所要上传到的数据库
            
            
            /**
            *构造方法,用来实例化备份类对象
            *@param    string    $fileName      SQL文件名称
            */
            function __construct($fileName) {
                $this->database = "lighting";                           //操作数据库名,默认为lighting
                $this->fileName = $fileName;
            }
            
            /*公共函数,用于进行数据文件上传*/
            public function restore() {
                if(!file_exists($this->path.$this->fileName)) {
                    $this->showMess("SQL文件不存在! 请检查", true);
                    
                    exit ();
                }
                
                /*检测是否包含分卷,将类似20120516211738_all_v1.sql从_v分开,有则说明有分卷*/
                $volume = explode("_v", $this->fileName);
                $volume_path = $volume[0];
                
                $this->showMess("请勿刷新及关闭浏览器以防止程序被中止,如有不慎!将导致数据库结构受损");
                $this->showMess("正在导入备份数据,请稍候!");
                
                /*无分卷sql文件导入*/
                if(count($volume) == 1) {
                    $this->showMess("正在导入sql:<span>".$this->fileName.'</span>');
                    
                    if($this->importInto($this->fileName)) {
                        $this->showMess("数据库导入成功! ");
                    }
                    else {
                        $this->showMess("数据库导入失败!", true);
                        exit();
                    }
                }
                /*有分卷导入*/
                else {
                    /*获取当前是第几分卷,循环执行余下分卷*/
                    $volume_id = explode(".sq", $volume[1]);
                    /*当前分卷为$volume_id*/
                    $volume_id = intval($volume_id[0]);                  //将string强制转换为int型
                    
                    while($volume_id) {
                        $tmpfile = $volume_path."_v".$volume_id.".sql";  //构造当前分卷文件名
                        
                        /*如果存在分卷就继续执行*/
                        if(file_exists($this->path.$tmpfile)) {
                            $this->showMess("正在导入分卷".$volume_id.':'.$tmpfile."<br />");
                            if($this->importInto($tmpfile)) {
                                $this->showMess("分卷".$volume_id.':'.$tmpfile."导入成功!<br />");
                            }
                            else {
                                $this->showMess("导入分卷<span style='color:#f00;'>".$tmpfile."</span>失败!可能是数据库结构已被破坏,请尝试从分卷一开始导入。", true);
                            }
                        }
                        else {
                            $this->showMess("分卷备份全部导入成功!");
                        }
                        
                        $volume_id ++;                                   //下一个分卷
                    }
                }
            }
            
            /**
            *类内部调用的私有方法,进行提示信息输出
            *@param string  $mess   提示信息
            *@param bool    $err    错误信息标示符,默认为false,true为输出错误信息
            */
            private function showMess($mess, $err = false) {
                if($err)
                    $err = "<span>ERROR:</span>";
                else 
                    $err = '';
                
                echo "<p>".$err.$mess."</p>";
            }
            
            /**
            *类内部调用的私有方法,将SQL导入数据库
            *@param string $sqlFile     导入的SQL文件名
            *@return    bool            返回写入是否成功,如果成功则返回true
            */
            private function importInto($sqlFile) {
                /*读取SQL文件*/
                $f = fopen($this->path.$sqlFile, "rb");
                /*创建表缓冲变量*/
                $create_table = '';
                while(!feof($f)) {
                    /*读取每一行sql*/
                    $line = fgets($f);
                    
                    /*这一步为了将创建表合成完整的sql语句*/
                    //如果结尾没有包含';'(即为一个完整的sql语句,这里是插入语句),并且不包含'ENGINE='(即创建表的最后一句)
                    if (!preg_match('/;/', $line) || preg_match('/ENGINE=/', $line)) {
                        /*将本次sql语句与创建表sql连接存起来*/
                        $create_table .= $line;
                        
                        /*如果包含了创建表的最后一句*/
                        if (preg_match('/ENGINE=/', $create_table)) {
                            /*执行sql语句创建表*/
                            $this->insertInto($create_table);
                            
                            /*清空当前,准备下一个表的创建*/
                            $create_table = '';
                        }
                        
                        /*跳过本次*/
                        continue;
                    }
                    
                    /*执行sql语句*/
                    $this->insertInto($line);
                }
                fclose ($f);
                
                return true;
            }
            
            /**
            *类内部调用的私有方法,插入单条sql语句
            *@return    bool    是否插入成功,成功返回true
            */
            private function insertInto($sql){
                if (!mysql_query(trim($sql))) {
                    $this->showMess(mysql_error(), true);
                    
                    return false;
                }
            }
            
            /*析构函数*/
            function __destruct() {
                echo "再见<br />";
            }
        }
        
    ?>

    
    展开全文
  • /**  *PHP面向对象:单态设计模式(连接数据库)  */  class DB{  private static $obj=null;  private function __construct(){  echo "连接数据库成功";  }  static functio
  • PHP面向对象操作数据库--MySQLI类

    千次阅读 2018-08-15 21:57:59
    自学PHP,这几天学到了连接数据库,干脆把MySQLI的API全过一遍吧!   MySQLI  代表PHP和Mysql数据库之间的一个连接。  1.mysqli::affected_rows :  返回影响到数据表的行数   &lt;?php $con=new ...
  • 这里用到的是mysqli,意思就是mysql的扩展,既可以通过面向过程的方式也可以通过面向对象的方式与数据库进行交互,唯一不同的是调用函数(对象方法)的方式不一样。   转载于:...
  • PHP面向对象的mysql数据库函数封装

    千次阅读 2015-09-08 22:19:32
    PHP4.0之后的版本很大的优势更加注重面向对象的编程。一般情况下,我们用一般方法进行数据库操作要分开写很多方法。用面向对象的方法会增强开发效率。下面给出面向对象编程的mysql数据库操作相关代码:   class...
  • PHP面向对象数据库类实现登录

    千次阅读 2012-12-22 21:19:52
    面向对象的思想在PHP5中得到更为广泛的应用,这里我们仅实现一个简单的db_class的数据库操作类来实现登录验证: db_class.php类的实现代码: <?php class dbclass { public $connection ; public $...
  • 一、面向对象 1. 链接数据库 $conn = @new mysqli("127.0.0.1","root","","mydb"); if($conn-&gt;connect_errno){ //返回链接错误号 // 返回链接错误信息 die("...
  • PHP连接数据库,实现最基本的增删改查(面向对象) PHP连接数据库,实现最基本的增删改查(面向过程)这篇文章中已经介绍了PHP连接数据库的方法以及最基本的对数据库的操作,但并没有实现模块化,所有的代码全都...
  • 1、创建mysql_class.php文件然后在该文件中创建Mysql类,并定义变量 1 2 3 4 5 6 7 8 9 10 11  class Mysql{  private $host;//服务器地址 ...
  • PDO面向对象操作数据库服务器

    千次阅读 2015-02-28 23:41:44
    1、PDO是PHP新版中推荐的基于面向对象操作数据库服务器的方式。 开启PDO_mysql相关扩展:在php.ini中修改extension=php_pdo_mysql.dll 重启apache 2、PDO操作数据库的基本使用步骤 连接,认证,发送SQL,等待...
  • 面向对象PHP中关于数据库部分的应用
  • 这次用PHP面向对象方式来操作数据库。当html界面有需求要访问数据库时,可以用这种方式在html界面进行数据库连接及操作。 话不多说,上代码: $dbhost="localhost"; $username="root"; $password="root"; $...
  • PHP使用面向对象的方式操作数据库

    千次阅读 2018-04-06 14:56:24
    // 连接数据库 @$db=new mysqli('localhost','root','123','user1_test'); if($db-&gt;connect_errno)//连接成功代码为0,失败代码为1 { die('数据库连接失败: '.$db-&gt;connect_error); } // 模拟表单...
  • PDO方式连接数据库PHP连接数据库

    千次阅读 2020-05-04 15:49:25
    四、通过PDO连接数据库4.1 PDO的构造函数4.1.1 exec()方法 返回执行后受影响的行数4.1.2 query()方法 用于返回执行查询后的结果集 一、什么是PDO? PDO是PHP Date Object(PHP数据对象)的简...
  • 相信开始学习PHP的伙伴们用的都是php4,或者php5,在这些版本中都有一个连接数据库的函数mysql_connect(),但在使用php5.5及5.5以上版本时,你会发现使用mysql_connect()会直接报错,这是因为php5.5以后的版本考虑...
  • 首先封装好mysql类 mysql.php <?php class Mysql{ private static $host="localhost"; private static $user="root"; private static $password="123456"; private static $dbName=
  • 1、和mysql扩展库的区别: (1 安全性、稳定性更高 (2 提供了面向对象和面向过程两种风格 ...3、面向对象:查询列表<?php 3 //mysqli 操作数据(面向对象风格) 5 #1、创建Mysql对象 7 $mysqli=new MySQLi("1
  • 新闻主页面(main_screen.php) 代码如下: 新闻查询 ☾新闻管理☽ 查询新闻 添加新闻 删除新闻 二.新闻查询部分的设计 1.查询页面的设计(main_new.php) 新闻查询 查询新闻的关键字 返回主...
  • PHP7 连接数据库

    2019-04-17 15:13:02
    PHP5 及之后,能够连接数据库的只有如下两种方法: MySQLi extension(i代表提高) PDO (PHP Data Objects) 更早的版本可以用mysql库来连接mysql数据库,但是mysql 库在2012年就被遗弃了,官方不在进行维护。 ...
  • <?php /** * Created by PhpStorm. * User: Flying * Date: 2016/9/27 * Time: 19:10 */ function println($msg) { echo ""; echo $msg; } $mysql_server_name = ... //改成自己的mysql数据库服务器 $m
  • 1.mysqli以面向对象的方式连接数据库 2.以面向对象的方式新增数据库 3.以面向对象的方式新增数据表 4.以面向对象的方式在数据表中增加记录 5.以面向对象的方式在数据表中查找记录 6.以面向对象的方式修改记录 ...
  • //连接数据库,试用面向对象的方法 //1.连接数据库 @$db=new mysqli('localhost'); if (!$db) { echo "数据库连接错误!!";exit;} else echo"数据库连接成功!!"; //2.选择数据库 $db->select_db('php'); //3.数据库...
  • PHP7的连接数据库的三种方法
  • /*一个文件MySQLDB.class.php中包含了一个类来连接数据库、 执行语句的方法、 将查询到的结果集通过数组返回的方法。 */ <?php //类名与文件名类似 //可连接数据库 //并实现其单类模式, //还能完成基本mysql...
  • PHP连接mysql数据库

    2019-05-22 17:56:45
    PHP连接mysql数据库是PHP新手们必须要掌握的一项技能,只要掌握了PHP对数据库进行增删改查等操作,就可以写出一些简单且常见的程序。...mysqli连接数据库和pdo连接数据库有两种方法。 第一种方法:使用mysqli连接my...
  • //连接数据库 $mysqli=mysqli_connect('localhost','root','root','test'); if(!$mysqli){ die("连接失败".mysqli_connect_error($mysqli)); } // 设置数据库编码 mysqli_query($mysqli,"set names utf8"); //进行...
  • php5.3版本之后,想要连接数据库有两种方案,一种是通过mysqli,另外外一种是通过PDO,而通过mysqli来连接数据库也可也分为两种情况: mysqli(面向对象),mysqli(面向过程). 即三种方式: 1)PDO连接mysql 2)mysqli(面向...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,464
精华内容 12,985
关键字:

php面向对象连接数据库