相关疑难解决方法(0)

我有一个我觉得非常沉重的动作结果,所以我想知道如何优化它以便它获得更好的性能.此Web应用程序将同时由+ 100,000个用户使用.

现在我的Actionresult做了以下事情:

• 从Internet URL检索XML文件
• 将xml数据填充到我的数据库
• 数据库数据填充了我的Viewmodel
• 将模型返回到视图

每次用户访问视图时,此4个函数都会触发.这就是为什么我认为这个Actionresult非常糟糕.

如何将以下内容添加到我的Actionresults中？

添加计时器来检索XML文件并将xml数据填充到DB,就像每10分钟一样,因此每次用户访问视图时都不会触发.每次用户访问站点时,唯一需要触发的功能是viewmodel绑定并返回模型.我怎么能做到这一点？

注意:

• xml文件每10分钟左右更新一次新数据.
• 我有大约50个动作结果,它们执行相同的获取xml数据并添加到数据库但有50个不同的xml文件.
• 如果xml URL处于脱机状态,则应跳过整个xml检索和数据库添加,然后执行模型绑定

这是我的行动结果:

public ActionResult Index()
        {
            //Get data from xml url (This is the code that shuld not run everytime a user visits the view)
            var url = "http://www.interneturl.com/file.xml";
            XNamespace dcM = "http://search.yahoo.com/mrss/";
            var xdoc = XDocument.Load(url);
            var items = xdoc.Descendants("item")
            .Select(item => new
            {
                Title = item.Element("title").Value,
                Description = item.Element("description").Value,
                Link = item.Element("link").Value,
                PubDate = item.Element("pubDate").Value, 
                MyImage = (string)item.Elements(dcM + "thumbnail")
               .Where(i => i.Attribute("width").Value …

实现了一对多关系,并且工作正常.

我的问题是当我运行以下查询时,如果该表有100个员工行,并且每个员工有2个部门.数据库查询被调用101次,因为对于每个员工来说它正在调用部门查询,完成调用所有100行需要很长时间,任何人都可以建议任何替代解决方案吗？

请参阅下面的详细信息

它正在调用的查询:

    First query is :    SELECT * FROM Employee e

    Next 100 queries : SELECT * FROM DEPARTMENT d WHERE d.EmployeeId=?

JPA数据库调用:

    javax.persistence.Query query = em.createNamedQuery("SELECT * FROM Employee e", Employee.class);

    return query.getResultList();




    import javax.persistence.CascadeType;
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.FetchType;
    import javax.persistence.Id;
    import javax.persistence.NamedNativeQueries;
    import javax.persistence.NamedNativeQuery;
    import javax.persistence.OneToMany;
    import javax.persistence.Table;

    @Entity
    @Table(name = "EMPLOYEE")
    public class Employee implements Serializable
    {
        @Id
        @Column(name = "EmployeeId")
        String employeeId;

        @OneToMany(mappedBy = "employee", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
        private …

与任何其他框架一样,Hibernate强加了一些限制.一个非常受欢迎的面试问题是:

"你对Hibernate遇到了什么样的困难？"

例如:

1. 懒惰的一对二双向是不可能的.
2. 会话结束后加载延迟收集.当您使用DAO + Spring事务时会发生这种情况.你可以在这里阅读它.
3. 在群集应用程序上同时更新时遇到麻烦
4. N + 1选择问题

问:你可以补充一下这个简单的清单吗？

PS 当你是Hibernate的新手时,我并不是说那些困难,现在不知道如何映射多对多.我的意思是在使用这个框架时,每个有经验的程序员面临的困难.

我试图了解n + 1问题，从而找到适当的解决方法。

我有两个实体：公司

@Entity
@Table(name="company")
public class Company implements Serializable {

    private static final long serialVersionUID = 1L;


    @Id
    @GeneratedValue
    private int id;

    @Column(name="cmp_id")
    private int cmpId;

    @Column(name="company_name")
    private String companyName;

    @OneToMany(fetch=FetchType.LAZY)
    @JoinColumn(name="cmp_id",referencedColumnName="cmp_id")
    private Set<Employee> employee;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getCmpId() {
        return cmpId;
    }

    public void setCmpId(int cmpId) {
        this.cmpId = cmpId;
    }

    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) …

我对 mapstruct 中的 @ManyToOne 映射有疑问。我有两张桌子

第一个：

@Entity
@Table(name = "members", schema = vsm)
public class MemberEntity{

    @Column(name = "id", nullable = false)
    protected Long id;

    @ManyToOne(optional = false)
    @JoinColumn(name = "case_id", nullable = false)
    private CaseEntity case;
}

第二个：

@Entity
@Table(name = "cases", schema = vsm)
public class CaseEntity {

    @Column(name = "id", nullable = false)
    protected Long id;

    @Column(name = "description", nullable = false)
    protected String description;
}

我有一个像这样的案例：

public class CasesDto{

    protected Long id;

    protected String description;

    private …

是否存在使用 Hibernate 的额外延迟加载可能很危险的场景？

文档说：“Extra-lazy”集合获取：根据需要从数据库访问集合的各个元素。除非绝对需要，否则 Hibernate 会尽量不将整个集合提取到内存中。它适用于大型收藏。

我不确定我是否理解这的含义 - 这是否意味着如果我声明所有关联都特别懒惰，无论它们的大小如何，我都会失去性能？关于额外延迟加载的使用是否有某种经验法则？

我正在使用Xamarin表单,SQLite.net和SQLitenet扩展,我无法弄清楚为什么我希望简单的东西不起作用.

我有两节课

public class MeasurementInstanceModel
{
    public MeasurementInstanceModel ()
    {
    }

    [PrimaryKey]
    [AutoIncrement]
    public int Id {
        get;
        set;
    }

    [ForeignKey(typeof(MeasurementDefinitionModel))]
    public int MeasurementDefinitionId {
        get;
        set;
    }

    [ManyToOne(CascadeOperations = CascadeOperation.CascadeRead)]
    public MeasurementDefinitionModel Definition {
        get;
        set;
    }

    [ForeignKey(typeof(MeasurementSubjectModel))]
    public int MeasurementSubjectId {
        get;
        set;
    }

    [ManyToOne(CascadeOperations = CascadeOperation.CascadeRead)]
    public MeasurementSubjectModel Subject {
        get;
        set;
    }

    public DateTime DateRecorded {
        get;
        set;
    }

    [OneToMany(CascadeOperations = CascadeOperation.All)]
    public List<MeasurementGroupInstanceModel> MeasurementGroups {
        get;
        set;
    }
}

和

public class MeasurementSubjectModel
{


    [PrimaryKey] …

我从未听说过，但人们将应用程序中的问题称为“N+1 问题”。他们正在做一个基于 Linq to SQL 的项目，有人发现了一个性能问题。我不太明白 - 但希望有人能引导我。

似乎他们正在尝试获取 obects 列表，然后在此之后的 Foreach 导致过多的数据库命中：

据我了解，源代码的第二部分仅在 forwach 中加载。

因此，加载的项目列表：

var program = programRepository.SingleOrDefault(r => r.ProgramDetailId == programDetailId);

然后，我们使用这个列表：

foreach (var phase in program.Program_Phases)
{
    phase.Program_Stages.AddRange(stages.Where(s => s.PhaseId == phase.PhaseId));
    phase.Program_Stages.ForEach(s =>
    {
         s.Program_Modules.AddRange(modules.Where(m => m.StageId == s.StageId));
    });
    phase.Program_Modules.AddRange(modules.Where(m => m.PhaseId == phase.PhaseId));
}

似乎确定的问题是，他们希望“程序”包含它的孩子。但是当我们在查询中引用孩子时，它会重新加载程序：

program.Program_Phases

他们期望程序完全加载并在内存中，并且分析器似乎表明该程序表，所有连接都在每个“foreach”上被调用。

这有意义吗？

（编辑：我找到了这个链接： linq to sql 会自动延迟加载关联实体吗？ 这可能会回答我的问题，但是 .. 他们正在使用更好的 (where person in...) 符号，而不是这个奇怪的 (x => x....）所以如果这个链接是答案——也就是说，我们需要“加入”查询——可以做到吗？）

我们正在尝试优化我们的一些方法.我们使用Redgate的Performance Profiler来查找一些性能泄漏.

我们的工具在几种方法中使用Linq来对象.但我们注意到,FirstOrDefault对于具有+/- 1000个对象的集合,需要很长时间.

探查器还会警告查询非常慢.我已经使用探查器结果添加了图像.

无法将集合添加到数据库,然后查询数据库.有什么建议？

谢谢 !

private SaldoPrivatiefKlantVerdeelsleutel GetParentSaldoPrivatiefKlantVerdeelsleutel(SaldoPrivatiefKlantVerdeelsleutel saldoPrivatiefKlantVerdeelsleutel, SaldoGebouwRekeningBoeking boeking, int privatiefKlant)
{
    SaldoPrivatiefKlantVerdeelsleutel parentSaldoPrivatiefKlantVerdeelsleutel = null;

    if (saldoPrivatiefKlantVerdeelsleutel != null)
    {
        try
        {
            parentSaldoPrivatiefKlantVerdeelsleutel = saldoPrivatiefKlantVerdeelsleutel.AfrekenPeriode.SaldoPrivatiefKlantVerdeelsleutelCollection
                .FirstOrDefault(s => (boeking == null || (s.SaldoVerdeelsleutel != null &&
                (s.SaldoVerdeelsleutel.GebouwVerdeelSleutel.ID == boeking.SaldoGebouwRekeningVerdeling.SaldoGebouwRekening.SaldoVerdeelsleutel.GebouwVerdeelSleutel.ID)))
                && s.PrivatiefKlant.ID == privatiefKlant);
        }
        catch (Exception ex)
        { }
    }

    return parentSaldoPrivatiefKlantVerdeelsleutel;
}

图像: 个人资料报告

我想使用 list_display 显示所有宠物主人（客户），并为每个主人显示他们所有宠物（患者）的逗号分隔列表。

外键在Patient表中，这样一个主人可以有很多宠物，但一个宠物只能有一个主人。

我有以下工作，但想要一些关于这是否是可接受的方法的建议。

from .models import Client, Patient

class ClientAdmin(admin.ModelAdmin):
    list_display = ('first_name', 'last_name', 'mobile', 'patients')

    def patients(self,obj):
        p = Patient.objects.filter(client_id=obj.pk)
        return list(p)

这是它的样子：

感谢您的任何指导。

更新：这是我目前所处的位置：

这是我迄今为止设法开始工作的内容

class ClientAdmin(admin.ModelAdmin):
    list_display = ('first_name', 'last_name', 'mobile', 'getpatients')
    def getpatients(self, request):
        c = Client.objects.get(pk=1)
        p = c.patient_fk.all()
        return p

这是遵循文档 re: following关系向后。

当然，上面的示例将客户端对象的数量“固定”为一个 (pk=1)，因此我不确定如何获得所有客户端的结果。

@pleasedontbelong - 我试过你的代码，非常感谢。我几乎肯定做错了什么，因为我收到了一个错误。但是你知道 FK 现在有

 related_name = 'patient_fk'

这解释了为什么我不使用patient_set（因为FOO_set被覆盖）

所以这就是我所拥有的：

class ClientAdmin(admin.ModelAdmin):
    list_display = ('first_name', 'last_name', 'mobile', 'getpatients')

    def get_queryset(self, request):
        qs = super(ClientAdmin, self).get_queryset(request)
        return …