Jscroop
Jscroop

学习ASP.NET Core(03)-数据层逻辑层与模型转换

上一篇我们使用Code First的方式完成了数据库的建立 ，本章我们来完善一下数据访问层和业务逻辑层部分的内容

一、IDAL与DAL

根据依赖倒置原则，细节应该依赖于抽象，我们我们要针对抽象，即面向接口进行编程，其好处是解耦和利于重构

1、IDAL实现

1.1、基类接口

这里添加一个CURD操作的基类接口，名为IBaseRepository，其余每个model都对应一个接口并继承该基类接口。在这之前IDAL层需要添加对Model层的引用。如下：

using System;
using System.Linq;
using System.Threading.Tasks;
using BlogSystem.Model;

namespace BlogSystem.IDAL
{
    /// 
    /// 基类接口
    /// 
    /// 
    public interface IBaseRepository where TEntity : BaseEntity
    {
        /// 
        /// 新增数据
        /// 
        /// 
        /// 
        /// 
        Task CreateAsync(TEntity entity, bool saved = true);

        /// 
        /// 根据Id删除数据
        /// 
        /// 
        /// 
        /// 
        Task RemoveAsync(Guid id, bool saved = true);

        /// 
        /// 根据model删除对数据
        /// 
        /// 
        /// 
        /// 
        Task RemoveAsync(TEntity entity, bool saved = true);

        /// 
        /// 修改数据
        /// 
        /// 
        /// 
        /// 
        Task EditAsync(TEntity entity, bool saved = true);

        /// 
        /// 通过Id查询数据
        /// 
        /// 
        /// 
        Task GetOneByIdAsync(Guid id);

        /// 
        /// 获取所有数据
        /// 
        /// 
        IQueryable GetAll();

        /// 
        /// 获取所有数据并排序
        /// 
        /// 
        IQueryable GetAllByOrder(bool asc = true);

        /// 
        /// 统一保存方法
        /// 
        /// 
        Task SavedAsync();

        /// 
        /// 判断对象是否存在
        /// 
        /// 
        /// 
        Task Exists(Guid id);
    }
}

1.2、其余接口

其余的每个model也都定义一个接口并继承IBaseRepository，给出一个示例，其余需要一一对应如下：

using BlogSystem.Model;

namespace BlogSystem.IDAL
{
    public interface IArticleRepository : IBaseRepository

    {
    }
}

学习ASP.NET Core(03)-数据层逻辑层与模型转换_第1张图片

2、DAL实现

2.1、基类方法

首先DAL层需要添加对Model层和DAL层的引用，然后我们在DAL项目下添加一个名为BaseRepository的类，并继承基类接口IBaseRepository，添加泛型约束泛型参数为BlogSystem.Model中的BaseEntity，实现如下:

using System;
using System.Linq;
using System.Threading.Tasks;
using BlogSystem.IDAL;
using BlogSystem.Model;
using Microsoft.EntityFrameworkCore;

namespace BlogSystem.DAL
{
    /// 
    /// 实现基类接口
    /// 
    /// 
    public class BaseRepository : IBaseRepository where TEntity : BaseEntity, new()
    {
        private readonly BlogSystemContext _context;

        public BaseRepository(BlogSystemContext context)
        {
            _context = context;
        }

        /// 
        /// 新增数据
        /// 
        /// 
        /// 
        /// 
        public async Task CreateAsync(TEntity entity, bool saved = true)
        {
            _context.Set().Add(entity);
            if (saved) await _context.SaveChangesAsync();
        }

        /// 
        /// 根据Id删除数据
        /// 
        /// 
        /// 
        /// 
        public async Task RemoveAsync(Guid id, bool saved = true)
        {
            var t = new TEntity() { Id = id };
            _context.Entry(t).State = EntityState.Unchanged;
            t.IsRemoved = true;
            if (saved) await _context.SaveChangesAsync();
        }

        /// 
        /// 根据model删除数据
        /// 
        /// 
        /// 
        /// 
        public async Task RemoveAsync(TEntity model, bool saved = true)
        {
            await RemoveAsync(model.Id, saved);
        }

        /// 
        ///  修改数据
        /// 
        /// 
        /// 
        /// 
        public async Task EditAsync(TEntity entity, bool saved = true)
        {
            _context.Entry(entity).State = EntityState.Modified;

            //如果数据没有发生变化
            if (!_context.ChangeTracker.HasChanges()) return;

            if (saved) await _context.SaveChangesAsync();
        }

        /// 
        /// 通过Id查询数据
        /// 
        /// 
        /// 
        public async Task GetOneByIdAsync(Guid id)
        {
            return await GetAll().FirstOrDefaultAsync(m => m.Id == id);
        }

        /// 
        /// 获取所有数据
        /// 
        /// 
        public IQueryable GetAll()
        {
            return _context.Set().Where(m => !m.IsRemoved).AsNoTracking();
        }

        /// 
        /// 获取所有数据并排序
        /// 
        /// 
        public IQueryable GetAllByOrder(bool asc = true)
        {
            var data = GetAll();
            data = asc ? data.OrderBy(m => m.CreateTime) : data.OrderByDescending(m => m.CreateTime);
            return data;
        }

        /// 
        /// 统一保存方法
        /// 
        /// 
        public async Task SavedAsync()
        {
            await _context.SaveChangesAsync();
        }

        /// 
        /// 确认对象是否存在
        /// 
        /// 
        /// 
        public async Task Exists(Guid id)
        {
            return await GetAll().AnyAsync(m => m.Id == id);
        }
    }
}

2.2、其余方法

其余IDAL中的接口采用继承的方式实现，给出一个示例，其余同理，如下：

    public class ArticleCommentRepository : BaseRepository, IArticleCommentRepository
    {
        public ArticleCommentRepository() : base(new BlogSystemContext(new DbContextOptions()))
        {
        }
    }

学习ASP.NET Core(03)-数据层逻辑层与模型转换_第2张图片

二、模型对象

1、概念

在DAL层我们是对数据库的直接操作，面向的也是我们设计的包含属性的model；但在BLL层，面向的是业务逻辑，业务逻辑对应的是用户的操作，在软件的实际使用过程中，用户看到的页面并非对应一个完整的model，页面可能是model的一部分，也有可能由几个model的一部分组合而成的。为了解决这类问题，我们通常使用模型对象

2、常用的两种模型对象

1、Dto(Data Transfer Object)：又名数据传输对象，常用来定义包含属性的实体类，它只引用基本数据类型，不引用对象类型，且没有行为，它只专注于数据本身，一般用于DAL和BLL之间的数据传输；

2、ViewModel：又名视图模型，它根据View创建，是View的数据容器，它专注的是View，用来呈现给用户，它由一个或多个Dto的组成；

3、实际应用

根据上面的描述，DAL与BLL层的数据交互我们应该使用Dto对象，呈现给页面时需要使用ViewModel对应，但在实际的开发中，Dto与ViewModel重合度很高，所以部分开发者只使用一种，但兼并两类角色。此外，Model与Dto/ViewModel之间的转换，我们可以使用EF的Select方法进行投影解决，或者使用AutoMapper之类的插件。

三、IBLL与ViewModel

这里我们根据功能大类，分为用户，文章、分类和评论，所以在IBLL中我们暂时先添加这4个接口， 在这之前需要添加对Model层的引用。根据实体对象部分的讲述，我们在Model层添加一个ViewModels文件夹，里面用来放置ViewModel对象，ViewModel对象属性通常会使用一些特性限制用户的录入。

1、基类接口

我们发现可以提取出常用的几个方法，避免重复代码，操作如下:

using BlogSystem.Model;
using System;
using System.Threading.Tasks;

namespace BlogSystem.IBLL
{
    /// 
    /// 基类服务接口
    /// 
    /// 
    public interface IBaseService where TEntity : BaseEntity
    {
        /// 
        /// 根据Id删除实体
        /// 
        /// 
        /// 
        Task RemoveAsync(Guid id);

        /// 
        /// 删除实体
        /// 
        /// 
        /// 
        Task RemoveAsync(TEntity entity);

        /// 
        /// 通过Id查询实体
        /// 
        /// 
        /// 
        Task GetOneByIdAsync(Guid id);

        /// 
        /// 判断实体是否存在
        /// 
        /// 
        /// 
        Task ExistsAsync(Guid id);
    }
}

2、文章接口与ViewModel

1、在Model层的ViewModel中添加相关的ViewModel，即用户所视内容需要用到的属性

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace BlogSystem.Model.ViewModels
{
    /// 
    /// 创建文章
    /// 
    public class CreateArticleViewModel
    {
        /// 
        /// 创建用户Id
        /// 
        public Guid UserId { get; set; }

        /// 
        /// 文章标题
        /// 
        [Required]
        public string Title { get; set; }

        /// 
        /// 文章内容
        /// 
        [Required]
        public string Content { get; set; }

        /// 
        /// 文章分类
        /// 
        public List CategoryIds { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace BlogSystem.Model.ViewModels
{
    /// 
    /// 编辑文章
    /// 
    public class EditArticleViewModel
    {
        /// 
        /// 文章Id
        /// 
        public Guid Id { get; set; }

        /// 
        /// 文章标题
        /// 
        [Required]
        public string Title { get; set; }

        /// 
        /// 文章内容
        /// 
        [Required]
        public string Content { get; set; }

        /// 
        /// 文章分类
        /// 
        public List CategoryIds { get; set; }
    }
}

using System;

namespace BlogSystem.Model.ViewModels
{
    /// 
    /// 文章列表
    /// 
    public class ArticleListViewModel
    {
        /// 
        /// 文章Id
        /// 
        public Guid ArticleId { get; set; }

        /// 
        /// 文章标题
        /// 
        public string Title { get; set; }

        /// 
        /// 文章内容
        /// 
        public string Content { get; set; }

        /// 
        /// 创建时间
        /// 
        public DateTime CreateTime { get; set; }

        /// 
        /// 账号
        /// 
        public string Account { get; set; }

        /// 
        /// 头像
        /// 
        public string ProfilePhoto { get; set; }
    }
}

using System;
using System.Collections.Generic;

namespace BlogSystem.Model.ViewModels
{
    /// 
    /// 文章详情
    /// 
    public class ArticleDetailsViewModel
    {
        /// 
        /// 文章Id
        /// 
        public Guid Id { get; set; }

        /// 
        /// 文章标题
        /// 
        public string Title { get; set; }

        /// 
        /// 文章内容
        /// 
        public string Content { get; set; }

        /// 
        /// 创建时间
        /// 
        public DateTime CreateTime { get; set; }

        /// 
        /// 作者
        /// 
        public string Account { get; set; }

        /// 
        /// 头像
        /// 
        public string ProfilePhoto { get; set; }

        /// 
        /// 分类Id
        /// 
        public List CategoryIds { get; set; }

        /// 
        /// 分类名称
        /// 
        public List CategoryNames { get; set; }

        /// 
        /// 看好人数
        /// 
        public int GoodCount { get; set; }
        /// 
        /// 不看好人数
        /// 
        public int BadCount { get; set; }

    }
}

2、接口实现：IArticleService继承基类接口，并添加如下方法：

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using BlogSystem.Model;
using BlogSystem.Model.ViewModels;

namespace BlogSystem.IBLL
{
    /// 
    /// 文章接口
    /// 
    public interface IArticleService : IBaseService

    {
        /// 
        /// 新增文章
        /// 
        /// 
        /// 
        Task CreateArticleAsync(CreateArticleViewModel model);

        /// 
        /// 编辑文章
        /// 
        /// 
        /// 
        Task EditArticleAsync(EditArticleViewModel model);

        /// 
        /// 通过Id获取文章详情
        /// 
        /// 
        /// 
        Task GetArticleDetailsByArticleIdAsync(Guid articleId);

        /// 
        /// 通过用户Id获取文章列表
        /// 
        /// 
        /// 
        Task> GetArticlesByUserIdAsync(Guid userId);

        /// 
        /// 通过分类Id获取所有文章
        /// 
        /// 
        /// 
        Task> GetArticlesByCategoryIdAsync(Guid categoryId);

        /// 
        /// 通过用户Id获取文章数量
        /// 
        /// 
        /// 
        Task GetArticleCountByUserIdAsync(Guid userid);

        /// 
        /// 点赞文章
        /// 
        /// 
        /// 
        Task AddGoodCount(Guid articleId);

        /// 
        /// 点灭文章
        /// 
        /// 
        /// 
        Task AddBadCount(Guid articleId);
    }
}

3、分类接口与ViewModel

1、在Model层的ViewMode文件夹中添加相关的ViewModel

using System;
using System.ComponentModel.DataAnnotations;

namespace BlogSystem.Model.ViewModels
{
    public class CreateOrEditCategoryViewModel
    {
        /// 
        /// 分类名称
        /// 
        [Required]
        public string CategoryName { get; set; }

        /// 
        /// 创建用户Id
        /// 
        public Guid UserId { get; set; }
    }
}

namespace BlogSystem.Model.ViewModels
{
    public class CategoryListViewModel
    {
        /// 
        /// 分类名称
        /// 
        public string CategoryName { get; set; }
    }
}

2、分类接口：继承基类接口，并添加如下方法：

using BlogSystem.Model;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using BlogSystem.Model.ViewModels;

namespace BlogSystem.IBLL
{
    /// 
    /// 分类服务接口
    /// 
    public interface ICategoryService : IBaseService
    {
        /// 
        /// 创建分类
        /// 
        /// 
        /// 
        Task CreateCategory(CreateOrEditCategoryViewModel model);

        /// 
        /// 编辑分类
        /// 
        /// 
        /// 
        Task EditCategory(CreateOrEditCategoryViewModel model);

        /// 
        /// 通过用户Id获取所有分类
        /// 
        /// 
        /// 
        Task> GetCategoryByUserIdAsync(Guid userId);
    }
}

4、用户接口与ViewModel

1、在Model层的ViewModel文件夹中添加相关的ViewModel

using System;
using System.ComponentModel.DataAnnotations;

namespace BlogSystem.Model.ViewModels
{
    /// 
    /// 用户注册
    /// 
    public class RegisterViewModel
    {
        /// 
        /// 账号
        /// 
        [Required]
        public string Account { get; set; }

        /// 
        /// 密码
        /// 
        [Required]
        public string Password { get; set; }

        /// 
        /// 确认密码
        /// 
        [Required]
        public string RequirePassword { get; set; }
    }
}

using System.ComponentModel;
using System.ComponentModel.DataAnnotations;

namespace BlogSystem.Model.ViewModels
{
    /// 
    /// 用户登录
    /// 
    public class LoginViewModel
    {
        /// 
        /// 账号
        /// 
        [Required]
        public string Account { get; set; }

        /// 
        /// 密码
        /// 
        [Required]
        public string Password { get; set; }
    }
}


using System;
using System.ComponentModel.DataAnnotations;

namespace BlogSystem.Model.ViewModels
{
    /// 
    /// 修改用户密码
    /// 
    public class ChangePwdViewModel
    {
        /// 
        /// 用户Id
        /// 
        public Guid UserId { get; set; }

        /// 
        /// 旧密码
        /// 
        [Required]
        public string OldPassword { get; set; }

        /// 
        /// 新密码
        /// 
        [Required]
        public string NewPassword { get; set; }

        /// 
        /// 确认新密码
        /// 
        [Required]
        public string RequirePassword { get; set; }
    }
}

using System;
using System.ComponentModel.DataAnnotations;

namespace BlogSystem.Model.ViewModels
{
    /// 
    /// 修改用户头像
    /// 
    public class ChangeUserPhotoViewModel
    {
        /// 
        /// 用户Id
        /// 
        public Guid UserId { get; set; }

        /// 
        /// 用户头像
        /// 
        [Required]
        public string ProfilePhoto { get; set; }
    }
}

using System;

namespace BlogSystem.Model.ViewModels
{
    /// 
    /// 修改用户资料
    /// 
    public class ChangeUserInfoViewModel
    {
        /// 
        /// 用户Id
        /// 
        public Guid UserId { get; set; }

        /// 
        /// 账号
        /// 
        public string Account { get; set; }

        /// 
        /// 出生日期
        /// 
        public DateTime BirthOfDate { get; set; }

        /// 
        /// 性别
        /// 
        public Gender Gender { get; set; }
    }
}

using System;

namespace BlogSystem.Model.ViewModels
{
    /// 
    /// 用户详细信息-点击查看主页
    /// 
    public class UserDetailsViewModel
    {
        /// 
        /// 用户Id
        /// 
        public Guid UserId { get; set; }
        /// 
        /// 账号
        /// 
        public string Account { get; set; }
        /// 
        /// 头像
        /// 
        public string ProfilePhoto { get; set; }
        /// 
        /// 年龄
        /// 
        public int Age { get; set; }
        /// 
        /// 性别
        /// 
        public Gender Gender { get; set; }
        /// 
        /// 用户等级
        /// 
        public Level Level { get; set; }
        /// 
        /// 粉丝数
        /// 
        public int FansNum { get; set; }
        /// 
        /// 关注数
        /// 
        public int FocusNum { get; set; }
    }
}

2、用户接口：添加用户方法，如下：

using System;
using BlogSystem.Model;
using BlogSystem.Model.ViewModels;
using System.Threading.Tasks;

namespace BlogSystem.IBLL
{
    /// 
    /// 用户服务接口
    /// 
    public interface IUserService : IBaseService
    {
        /// 
        /// 注册
        /// 
        /// 
        /// 
        Task Register(RegisterViewModel model);

        /// 
        /// 登录成功返回userId
        /// 
        /// 
        /// 
        Task Login(LoginViewModel model);

        /// 
        /// 修改用户密码
        /// 
        /// 
        /// 
        Task ChangePassword(ChangePwdViewModel model);

        /// 
        /// 修改用户头像
        /// 
        /// 
        /// 
        Task ChangeUserPhoto(ChangeUserPhotoViewModel model);

        /// 
        /// 修改用户信息
        /// 
        /// 
        /// 
        Task ChangeUserInfo(ChangeUserInfoViewModel model);

        /// 
        /// 使用account获取用户信息
        /// 
        /// 
        /// 
        Task GetUserInfoByAccount(string account);
    }
}

5、评论接口与ViewModel

1、在Model层的ViewModel文件夹中添加相关的ViewModel

using System;

namespace BlogSystem.Model.ViewModels
{
    public class CommentListViewModel
    {
        /// 
        /// 文章Id
        /// 
        public Guid ArticleId { get; set; }

        /// 
        /// 用户Id
        /// 
        public Guid UserId { get; set; }

        /// 
        /// 账号
        /// 
        public string Account { get; set; }

        /// 
        /// 评论Id
        /// 
        public Guid CommentId { get; set; }

        /// 
        /// 评论内容
        /// 
        public string CommentContent { get; set; }

        /// 
        /// 创建时间
        /// 
        public DateTime CreateTime { get; set; }

    }
}

2、评论接口：添加接口方法，如下：

using BlogSystem.Model;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using BlogSystem.Model.ViewModels;

namespace BlogSystem.IBLL
{
    /// 
    /// 评论服务接口
    /// 
    public interface ICommentService : IBaseService
    {
        /// 
        /// 添加评论
        /// 
        /// 
        /// 
        Task CreateComment(ArticleComment model);

        /// 
        /// 添加回复型评论
        /// 
        /// 
        /// 
        Task CreateReplyComment(CommentReply model);

        /// 
        /// 通过文章Id获取所有评论
        /// 
        /// 
        /// 
        Task> GetCommentsByArticleIdAsync(Guid articleId);
    }
}

我们这里暂时只是添加了目前考虑到的一些功能，后续以上的功能可能会进行相关的调整。

四、BLL实现

首先，我们需要对BLL层添加对Model，IDAL，IBLL的引用

1、基类方法

实现基类方法，如下：

using System;
using System.Threading.Tasks;
using BlogSystem.IBLL;
using BlogSystem.IDAL;
using BlogSystem.Model;

namespace BlogSystem.BLL
{
    /// 
    /// 基类方法
    /// 
    /// 
    public class BaseService : IBaseService where TEntity : BaseEntity, new()
    {
        //通过在子类的构造函数中注入，这里是基类，不用构造函数
        public IBaseRepository BaseRepository;

        /// 
        /// 根据Id删除对象
        /// 
        /// 
        /// 
        public async Task RemoveAsync(Guid id)
        {
            await BaseRepository.RemoveAsync(id);
        }

        /// 
        /// 根据实体删除对象
        /// 
        /// 
        /// 
        public async Task RemoveAsync(TEntity entity)
        {
            await BaseRepository.RemoveAsync(entity);
        }

        /// 
        /// 查询对象
        /// 
        /// 
        /// 
        public async Task GetOneByIdAsync(Guid id)
        {
            return await BaseRepository.GetOneByIdAsync(id);
        }

        /// 
        /// 判断对象是否存在
        /// 
        /// 
        /// 
        public async Task ExistsAsync(Guid id)
        {
            return await BaseRepository.Exists(id);
        }
    }
}

2、文章方法

文章方法实现如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using BlogSystem.IBLL;
using BlogSystem.IDAL;
using BlogSystem.Model;
using BlogSystem.Model.ViewModels;
using Microsoft.EntityFrameworkCore;

namespace BlogSystem.BLL
{
    /// 
    /// 实现文章接口方法
    /// 
    public class ArticleService : BaseService
, IArticleService
    {
        private readonly IArticleRepository _articleRepository;
        private readonly IArticleInCategoryRepository _articleInCategoryRepository;
        private readonly ICategoryRepository _categoryRepository;

        //构造函数注入相关接口
        public ArticleService(IArticleRepository articleRepository, IArticleInCategoryRepository articleInCategoryRepository,
        ICategoryRepository categoryRepository)
        {
            _articleRepository = articleRepository;
            BaseRepository = articleRepository;
            _articleInCategoryRepository = articleInCategoryRepository;
            _categoryRepository = categoryRepository;
        }

        /// 
        /// 创建文章
        /// 
        /// 
        /// 
        public async Task CreateArticleAsync(CreateArticleViewModel model)
        {
            //新增文章
            var article = new Article()
            {
                UserId = model.UserId,
                Title = model.Title,
                Content = model.Content
            };
            await _articleRepository.CreateAsync(article);

            //新增文章所属分类
            var articleId = article.Id;
            foreach (var categoryId in model.CategoryIds)
            {
                await _articleInCategoryRepository.CreateAsync(new ArticleInCategory()
                {
                    ArticleId = articleId,
                    CategoryId = categoryId
                }, false);
            }
            await _articleInCategoryRepository.SavedAsync();
        }

        /// 
        /// 编辑文章
        /// 
        /// 
        /// 
        public async Task EditArticleAsync(EditArticleViewModel model)
        {
            //保存文章更新
            var article = await _articleRepository.GetOneByIdAsync(model.Id);
            article.Title = model.Title;
            article.Content = model.Content;
            await _articleRepository.EditAsync(article);

            //删除所属分类
            var categoryIds = _articleInCategoryRepository.GetAll();
            foreach (var categoryId in categoryIds)
            {
                await _articleInCategoryRepository.RemoveAsync(categoryId, false);
            }
            //添加所属分类
            foreach (var categoryId in model.CategoryIds)
            {
                await _articleInCategoryRepository.CreateAsync(new ArticleInCategory()
                {
                    ArticleId = model.Id,
                    CategoryId = categoryId
                }, false);
            }
            //统一保存
            await _articleInCategoryRepository.SavedAsync();
        }

        /// 
        /// 获取文章详情
        /// 
        /// 
        /// 
        public async Task GetArticleDetailsByArticleIdAsync(Guid articleId)
        {
            var data = await _articleRepository.GetAll().Include(m => m.User).Where(m => m.Id == articleId)
                .Select(m => new ArticleDetailsViewModel
                {
                    Id = m.Id,
                    Title = m.Title,
                    Content = m.Content,
                    CreateTime = m.CreateTime,
                    Account = m.User.Account,
                    ProfilePhoto = m.User.ProfilePhoto,
                    GoodCount = m.GoodCount,
                    BadCount = m.BadCount
                }).FirstAsync();
            //处理分类
            var categories = await _articleInCategoryRepository.GetAll().Include(m => m.Category)
                .Where(m => m.ArticleId == data.Id).ToListAsync();
            data.CategoryIds = categories.Select(m => m.CategoryId).ToList();
            data.CategoryNames = categories.Select(m => m.Category.CategoryName).ToList();
            return data;
        }

        /// 
        /// 根据用户Id获取文章列表信息
        /// 
        /// 
        /// 
        public async Task> GetArticlesByUserIdAsync(Guid userId)
        {
            var list = await _articleRepository.GetAllByOrder(false).Include(m => m.User).Where(m => m.UserId == userId)
                .Select(m => new ArticleListViewModel()
                {
                    ArticleId = m.Id,
                    Title = m.Title,
                    Content = m.Content,
                    CreateTime = m.CreateTime,
                    Account = m.User.Account,
                    ProfilePhoto = m.User.ProfilePhoto
                }).ToListAsync();
            return list;
        }

        /// 
        /// 通过分类Id获取文章列表
        /// 
        /// 
        /// 
        public async Task> GetArticlesByCategoryIdAsync(Guid categoryId)
        {
            var data = await _categoryRepository.GetOneByIdAsync(categoryId);
            var userId = data.UserId;
            return await GetArticlesByUserIdAsync(userId);
        }

        /// 
        /// 获取用户文章数量
        /// 
        /// 
        /// 
        public async Task GetArticleCountByUserIdAsync(Guid userid)
        {
            return await _articleRepository.GetAll().CountAsync(m => m.UserId == userid);
        }

        /// 
        /// 看好数量+1
        /// 
        /// 
        /// 
        public async Task AddGoodCount(Guid articleId)
        {
            var article = await _articleRepository.GetOneByIdAsync(articleId);
            article.GoodCount++;
            await _articleRepository.EditAsync(article);
        }

        /// 
        /// 不看好数量+1
        /// 
        /// 
        /// 
        public async Task AddBadCount(Guid articleId)
        {
            var article = await _articleRepository.GetOneByIdAsync(articleId);
            article.BadCount--;
            await _articleRepository.EditAsync(article);
        }
    }
}

3、分类方法

实现分类方法，如下：

using BlogSystem.IBLL;
using BlogSystem.IDAL;
using BlogSystem.Model;
using BlogSystem.Model.ViewModels;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace BlogSystem.BLL
{
    public class CategoryService : BaseService, ICategoryService
    {
        private readonly ICategoryRepository _categoryRepository;

        public CategoryService(ICategoryRepository categoryRepository)
        {
            _categoryRepository = categoryRepository;
            BaseRepository = categoryRepository;
        }

        /// 
        /// 创建分类
        /// 
        /// 
        /// 
        public async Task CreateCategory(CreateOrEditCategoryViewModel model)
        {
            await _categoryRepository.CreateAsync(new Category()
            {
                UserId = model.UserId,
                CategoryName = model.CategoryName
            });
        }

        /// 
        /// 编辑分类
        /// 
        /// 
        /// 
        public async Task EditCategory(CreateOrEditCategoryViewModel model)
        {
            await _categoryRepository.EditAsync(new Category()
            {
                UserId = model.UserId,
                CategoryName = model.CategoryName
            });
        }

        /// 
        ///  通过用户Id获取所有分类
        /// 
        /// 
        /// 
        public Task> GetCategoryByUserIdAsync(Guid userId)
        {
            return _categoryRepository.GetAll().Where(m => m.UserId == userId).Select(m => new CategoryListViewModel
            {
                CategoryName = m.CategoryName
            }).ToListAsync();
        }
    }
}

4、用户方法

实现用户方法，如下：

using BlogSystem.IBLL;
using BlogSystem.IDAL;
using BlogSystem.Model;
using BlogSystem.Model.ViewModels;
using Microsoft.EntityFrameworkCore;
using System;
using System.Linq;
using System.Threading.Tasks;

namespace BlogSystem.BLL
{
    public class UserService : BaseService, IUserService
    {
        private readonly IUserRepository _userRepository;

        public UserService(IUserRepository userRepository)
        {
            _userRepository = userRepository;
            BaseRepository = userRepository;
        }

        /// 
        /// 用户注册
        /// 
        /// 
        /// 
        public async Task Register(RegisterViewModel model)
        {
           //判断账户是否存在
            if (!await _userRepository.GetAll().AnyAsync(m => m.Account == model.Account))
            {
                await _userRepository.CreateAsync(new User()
                {
                    Account = model.Account,
                    Password = model.Password
                });
            }
        }

        /// 
        /// 用户登录
        /// 
        /// 
        /// 
        public async Task Login(LoginViewModel model)
        {
            var user = await _userRepository.GetAll().FirstOrDefaultAsync(m => m.Account == model.Account && m.Password == model.Password);
            return user != null ? user.Id : new Guid();
        }

        /// 
        /// 修改用户密码
        /// 
        /// 
        /// 
        public async Task ChangePassword(ChangePwdViewModel model)
        {
            if (await _userRepository.GetAll().AnyAsync(m => m.Id == model.UserId && m.Password == model.OldPassword))
            {
                var user = await _userRepository.GetAll().FirstOrDefaultAsync(m => m.Id == model.UserId && m.Password == model.OldPassword);
                user.Password = model.NewPassword;
                await _userRepository.EditAsync(user);
            }
        }

        /// 
        /// 修改用户照片
        /// 
        /// 
        /// 
        public async Task ChangeUserPhoto(ChangeUserPhotoViewModel model)
        {
            var user = await _userRepository.GetAll().FirstAsync(m => m.Id == model.UserId);
            user.ProfilePhoto = model.ProfilePhoto;
            await _userRepository.EditAsync(user);
        }

        /// 
        /// 修改用户信息
        /// 
        /// 
        /// 
        public async Task ChangeUserInfo(ChangeUserInfoViewModel model)
        {
            var user = await _userRepository.GetAll().FirstAsync(m => m.Id == model.UserId);
            user.Account = model.Account;
            user.Gender = model.Gender;
            user.BirthOfDate = model.BirthOfDate;
            await _userRepository.EditAsync(user);
        }

        /// 
        /// 通过账号名称获取用户信息
        /// 
        /// 
        /// 
        public async Task GetUserInfoByAccount(string account)
        {
            if (await _userRepository.GetAll().AnyAsync(m => m.Account == account))
            {
                return await _userRepository.GetAll().Where(m => m.Account == account).Select(m =>
                    new UserDetailsViewModel()
                    {
                        UserId = m.Id,
                        Account = m.Account,
                        ProfilePhoto = m.ProfilePhoto,
                        Age = DateTime.Now.Year - m.BirthOfDate.Year,
                        Gender = m.Gender,
                        Level = m.Level,
                        FansNum = m.FansNum,
                        FocusNum = m.FocusNum
                    }).FirstAsync();
            }
            return new UserDetailsViewModel();
        }
    }
}

5、评论方法

实现评论方法，如下：

using BlogSystem.IBLL;
using BlogSystem.IDAL;
using BlogSystem.Model;
using BlogSystem.Model.ViewModels;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace BlogSystem.BLL
{
    public class CommentService : BaseService, ICommentService
    {
        private readonly IArticleCommentRepository _commentRepository;
        private readonly ICommentReplyRepository _commentReplyRepository;

        public CommentService(IArticleCommentRepository commentRepository, ICommentReplyRepository commentReplyRepository)
        {
            _commentRepository = commentRepository;
            BaseRepository = commentRepository;
            _commentReplyRepository = commentReplyRepository;
        }

        /// 
        /// 添加评论
        /// 
        /// 
        /// 
        public async Task CreateComment(ArticleComment model)
        {
            await _commentRepository.CreateAsync(model);
        }

        /// 
        /// 添加回复型评论
        /// 
        /// 
        /// 
        public async Task CreateReplyComment(CommentReply model)
        {
            await _commentReplyRepository.CreateAsync(model);
        }

        /// 
        /// 根据文章Id获取评论信息
        /// 
        /// 
        /// 
        public async Task> GetCommentsByArticleIdAsync(Guid articleId)
        {
            return await _commentReplyRepository.GetAllByOrder(false).Where(m => m.ArticleId == articleId)
                .Include(m => m.ArticleComment).Include(m => m.User).Select(m => new CommentListViewModel()
                {
                    ArticleId = m.ArticleId,
                    UserId = m.UserId,
                    Account = m.User.Account,
                    CommentId = m.Id,
                    CommentContent = m.Content,
                    CreateTime = m.CreateTime
                })
                .ToListAsync();
        }
    }
}
本章只是从整体上将DAL层和BLL的进行了初步的完善，后续会进一步调整，完~

本人知识点有限，若文中有错误的地方请及时指正，方便大家更好的学习和交流。

本文的代码结构和方法参考了B站一位UP主的视频内容，地址如下：任生风影

原创文章声明

你可能感兴趣的:(学习ASP.NET Core(03)-数据层逻辑层与模型转换)

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • 随笔 | 仙一般的灵气 海思沧海
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • 一百九十四章. 自相矛盾 巨木擎天
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 2021-08-26 影幽
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 第一场雪 岁月静好_nx
    早晨起来，外面白茫茫的一片，总算是下雪了，这还是今年第一场雪呢！走在路上，踩着雪“咯吱咯吱”的，空气很湿润。树上、草坪上、屋顶上都落了白白的一层，天上还零星漂着几点雪。慢慢走在路上，呼吸着清新的空气，感受着冬天的美好，心情也好多了。
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿 小鹿_33
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • 每日一题——第九十题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • 《庄子.达生9》 钱江潮369
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
  • 水泥质量纠纷案代理词 徐宝峰律师
    贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
  • 2019-12-22-22:30 涓涓1016
    今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • 将cmd中命令输出保存为txt文本文件 落难Coder Windowscmdwindow
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
  • 关于提高复杂业务逻辑代码可读性的思考 编程经验分享 开发经验java数据库开发语言
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
  • java工厂模式 3213213333332132 java抽象工厂
    工厂模式有 1、工厂方法 2、抽象工厂方法。 下面我的实现是抽象工厂方法, 给所有具体的产品类定一个通用的接口。 package 工厂模式; /** * 航天飞行接口 * * @Description * @author FuJianyong * 2015-7-14下午02:42:05 */ public interface SpaceF
  • nginx频率限制+python测试 ronin47 nginx 频率 python
           部分内容参考：http://www.abc3210.com/2013/web_04/82.shtml 首先说一下遇到这个问题是因为网站被攻击，阿里云报警，想到要限制一下访问频率，而不是限制ip（限制ip的方案稍后给出）。nginx连接资源被吃空返回状态码是502，添加本方案限制后返回599，与正常状态码区别开。步骤如下：
  • java线程和线程池的使用 dyy_gusi ThreadPoolthreadRunnabletimer
    java线程和线程池 一、创建多线程的方式     java多线程很常见，如何使用多线程，如何创建线程，java中有两种方式，第一种是让自己的类实现Runnable接口，第二种是让自己的类继承Thread类。其实Thread类自己也是实现了Runnable接口。具体使用实例如下： 1、通过实现Runnable接口方式 1 2
  • Linux 171815164 linux
    ubuntu kernel http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.1.2-unstable/ 安卓sdk代理 mirrors.neusoft.edu.cn        80 输入法和jdk sudo apt-get install fcitx su
  • Tomcat JDBC Connection Pool g21121 Connection
           Tomcat7 抛弃了以往的DBCP 采用了新的Tomcat Jdbc Pool 作为数据库连接组件，事实上DBCP已经被Hibernate 所抛弃，因为他存在很多问题，诸如：更新缓慢，bug较多，编译问题，代码复杂等等。        Tomcat Jdbc P
  • 敲代码的一点想法 永夜-极光 java随笔感想
                  入门学习java编程已经半年了,一路敲代码下来,现在也才1w+行代码量,也就菜鸟水准吧,但是在整个学习过程中,我一直在想,为什么很多培训老师,网上的文章都是要我们背一些代码?比如学习Arraylist的时候,教师就让我们先参考源代码写一遍,然
  • jvm指令集 程序员是怎么炼成的 jvm 指令集
    转自：http://blog.csdn.net/hudashi/article/details/7062675#comments       将值推送至栈顶时 const ldc  push   load指令 const系列 该系列命令主要负责把简单的数值类型送到栈顶。(从常量池或者局部变量push到栈顶时均使用) 0x02 &nbs
  • Oracle字符集的查看查询和Oracle字符集的设置修改 aijuans oracle
    本文主要讨论以下几个部分：如何查看查询oracle字符集、 修改设置字符集以及常见的oracle utf8字符集和oracle exp 字符集问题。 一、什么是Oracle字符集 Oracle字符集是一个字节数据的解释的符号集合,有大小之分,有相互的包容关系。ORACLE 支持国家语言的体系结构允许你使用本地化语言来存储，处理，检索数据。它使数据库工具，错误消息，排序次序，日期，时间，货
  • png在Ie6下透明度处理方法 antonyup_2006 css浏览器FirebugIE
    由于之前到深圳现场支撑上线，当时为了解决个控件下载，我机器上的IE8老报个错，不得以把ie8卸载掉，换个Ie6,问题解决了，今天出差回来，用ie6登入另一个正在开发的系统，遇到了Png图片的问题，当然升级到ie8(ie8自带的开发人员工具调试前端页面JS之类的还是比较方便的，和FireBug一样，呵呵)，这个问题就解决了，但稍微做了下这个问题的处理。 我们知道PNG是图像文件存储格式，查询资
  • 表查询常用命令高级查询方法(二) 百合不是茶 oracle分页查询分组查询联合查询
    ----------------------------------------------------分组查询 group by    having   --平均工资和最高工资   select avg(sal)平均工资,max(sal)  from emp ;  --每个部门的平均工资和最高工资
  • uploadify3.1版本参数使用详解 bijian1013 JavaScriptuploadify3.1
    使用：     绑定的界面元素<input id='gallery'type='file'/>$("#gallery").uploadify({设置参数，参数如下}); 设置的属性： id: jQuery(this).attr('id'),//绑定的input的ID langFile: 'http://ww
  • 精通Oracle10编程SQL(17)使用ORACLE系统包 bijian1013 oracle数据库plsql
    /* *使用ORACLE系统包 */ --1.DBMS_OUTPUT --ENABLE:用于激活过程PUT,PUT_LINE,NEW_LINE,GET_LINE和GET_LINES的调用 --语法：DBMS_OUTPUT.enable(buffer_size in integer default 20000); --DISABLE:用于禁止对过程PUT,PUT_LINE,NEW
  • 【JVM一】JVM垃圾回收日志 bit1129 垃圾回收
    将JVM垃圾回收的日志记录下来，对于分析垃圾回收的运行状态，进而调整内存分配(年轻代，老年代，永久代的内存分配)等是很有意义的。JVM与垃圾回收日志相关的参数包括： -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -Xloggc -XX:+PrintGC 通
  • Toast使用 白糖_ toast
    Android中的Toast是一种简易的消息提示框，toast提示框不能被用户点击，toast会根据用户设置的显示时间后自动消失。     创建Toast 两个方法创建Toast makeText(Context context, int resId, int duration)     参数：context是toast显示在
  • angular.identity boyitech AngularJSAngularJS API
    angular.identiy 描述: 返回它第一参数的函数. 此函数多用于函数是编程. 使用方法: angular.identity(value); 参数详解: Param Type Details value * to be returned. 返回值: 传入的value 实例代码: <!DOCTYPE HTML>
  • java-两整数相除，求循环节 bylijinnan java
    import java.util.ArrayList; import java.util.List; public class CircleDigitsInDivision { /** * 题目：求循环节，若整除则返回NULL，否则返回char*指向循环节。先写思路。函数原型：char*get_circle_digits(unsigned k,unsigned j)
  • Java 日期 周 年 Chen.H javaC++cC#
    /** * java日期操作(月末、周末等的日期操作) * * @author * */ public class DateUtil { /** */ /** * 取得某天相加(减)後的那一天 * * @param date * @param num *
  • [高考与专业]欢迎广大高中毕业生加入自动控制与计算机应用专业 comsci 计算机
          不知道现在的高校还设置这个宽口径专业没有,自动控制与计算机应用专业,我就是这个专业毕业的,这个专业的课程非常多,既要学习自动控制方面的课程,也要学习计算机专业的课程,对数学也要求比较高.....如果有这个专业,欢迎大家报考...毕业出来之后,就业的途径非常广.....      以后
  • 分层查询（Hierarchical Queries） daizj oracle递归查询层次查询
    Hierarchical Queries If a table contains hierarchical data, then you can select rows in a hierarchical order using the hierarchical query clause: hierarchical_query_clause::= start with condi
  • 数据迁移 daysinsun 数据迁移
    最近公司在重构一个医疗系统，原来的系统是两个.Net系统，现需要重构到java中。数据库分别为SQL Server和Mysql，现需要将数据库统一为Hana数据库，发现了几个问题，但最后通过努力都解决了。 1、原本通过Hana的数据迁移工具把数据是可以迁移过去的，在MySQl里面的字段为TEXT类型的到Hana里面就存储不了了，最后不得不更改为clob。 2、在数据插入的时候有些字段特别长
  • C语言学习二进制的表示示例 dcj3sjt126com cbasic
    进制的表示示例 # include <stdio.h> int main(void) { int i = 0x32C; printf("i = %d\n", i); /* printf的用法 %d表示以十进制输出 %x或%X表示以十六进制的输出 %o表示以八进制输出 */ return 0; }
  • NsTimer 和 UITableViewCell 之间的控制 dcj3sjt126com ios
    情况是这样的: 一个UITableView, 每个Cell的内容是我自定义的 viewA viewA上面有很多的动画, 我需要添加NSTimer来做动画, 由于TableView的复用机制, 我添加的动画会不断开启, 没有停止, 动画会执行越来越多.   解决办法: 在配置cell的时候开始动画, 然后在cell结束显示的时候停止动画   查找cell结束显示的代理
  • MySql中case when then 的使用 fanxiaolong casewhenthenend
    select "主键", "项目编号", "项目名称","项目创建时间", "项目状态","部门名称","创建人" union (select pp.id as "主键", pp.project_number as &
  • Ehcache（01）——简介、基本操作 234390216 cacheehcache简介CacheManagercrud
    Ehcache简介 目录 1       CacheManager 1.1      构造方法构建 1.2      静态方法构建 2       Cache 2.1&
  • 最容易懂的javascript闭包学习入门 jackyrong JavaScript
    http://www.ruanyifeng.com/blog/2009/08/learning_javascript_closures.html 闭包（closure）是Javascript语言的一个难点，也是它的特色，很多高级应用都要依靠闭包实现。 下面就是我的学习笔记，对于Javascript初学者应该是很有用的。 一、变量的作用域 要理解闭包，首先必须理解Javascript特殊
  • 提升网站转化率的四步优化方案 php教程分享 数据结构PHP数据挖掘Google活动
    网站开发完成后,我们在进行网站优化最关键的问题就是如何提高整体的转化率，这也是营销策略里最最重要的方面之一，并且也是网站综合运营实例的结果。文中分享了四大优化策略：调查、研究、优化、评估，这四大策略可以很好地帮助用户设计出高效的优化方案。 PHP开发的网站优化一个网站最关键和棘手的是，如何提高整体的转化率，这是任何营销策略里最重要的方面之一，而提升网站转化率是网站综合运营实力的结果。今天，我就分
  • web开发里什么是HTML5的WebSocket？ naruto1990 Webhtml5浏览器socket
    当前火起来的HTML5语言里面，很多学者们都还没有完全了解这语言的效果情况，我最喜欢的Web开发技术就是正迅速变得流行的 WebSocket API。WebSocket 提供了一个受欢迎的技术，以替代我们过去几年一直在用的Ajax技术。这个新的API提供了一个方法，从客户端使用简单的语法有效地推动消息到服务器。让我们看一看6个HTML5教程介绍里 的 WebSocket API：它可用于客户端、服
  • Socket初步编程——简单实现群聊 Everyday都不同 socket网络编程初步认识
    初次接触到socket网络编程，也参考了网络上众前辈的文章。尝试自己也写了一下，记录下过程吧：   服务端：（接收客户端消息并把它们打印出来）   public class SocketServer { private List<Socket> socketList = new ArrayList<Socket>(); public s
  • 面试：Hashtable与HashMap的区别（结合线程） toknowme
    昨天去了某钱公司面试，面试过程中被问道 Hashtable与HashMap的区别？当时就是回答了一点，Hashtable是线程安全的，HashMap是线程不安全的，说白了，就是Hashtable是的同步的，HashMap不是同步的，需要额外的处理一下。   今天就动手写了一个例子，直接看代码吧 package com.learn.lesson001; import java
  • MVC设计模式的总结 xp9802 设计模式mvc框架IOC
    随着Web应用的商业逻辑包含逐渐复杂的公式分析计算、决策支持等，使客户机越 来越不堪重负，因此将系统的商业分离出来。单独形成一部分，这样三层结构产生了。 其中‘层’是逻辑上的划分。 三层体系结构是将整个系统划分为如图2.1所示的结构[3] （1）表现层（Presentation layer）：包含表示代码、用户交互GUI、数据验证。 该层用于向客户端用户提供GUI交互，它允许用户
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他